Screenshots on Leon Mika

Devlog: CSVTool - A Vibe-coded CSV Editor

Sun, 08 Mar 2026 10:11:03 +1100

One of the fun aspects of these new code agents is seeing what they're capable of producing just form the prompt, so called "vibe-coding." There are some that are definitely all in on the concept: I'm thinking of Steve Yeggie and his Gas Town work. As for myself, I still prefer to be a bit more hands on. But it's still amusing to see what these agents are capable of just from the prompt.

I got inspired by Dave Winder's post about how he asked Claude Code to make a spreadsheet app for him. I use a TUI app I made for myself called Ted that I use to edit CSV files, but seeing how good Claude was in making the spreadsheet, I thought I'd ask Claude to make me a GUI version. This is what it came up with:

The results were pretty decent, at least on the surface. I haven't put it quite through it's paces for editing large CSV files, but what it managed to do out of the box was pretty impressive. Not that it's groundbreaking in any technical sense: think spreadsheet without the ability to define expressions. Most of the supportable commands are available via a command palette, invokable using Cmd+P. There are a few copy-and-paste options for getting table data out into usable formats, something I find quite frustrating with the spreadsheets I use. You can paste table data as CSV, a Markdown table, and Jira markup. There's the usual load, save, and commands to insert rows; all pretty standard.

It isn't perfect though. Despite two attempts to instruct it to make the header row fixed such that it won't scroll off the top, Claude was unable to achieve this. The techniques of making such a header are pretty hacky: the one I'm aware of is making a second table with just the header, placing it above the first, setting the position to absolute, then adding some JavaScript to keep the column widths in sync. Granted, this worked a good 18 years ago, and for tables that didn't scroll horizontally. Maybe there's a better way of doing this nowadays? Oh and speaking of the columns, despite providing affordances for resizing the columns, Claude didn't implement the code to actually resize them. This makes me wonder if HTML tables are probably not the best approach for such a control. I guess I probably should've told Claude that.

In any case, I'm not sure I'll put this to any real use. One thing I like about Ted is that it's modal, like Vim. Being able to move around using the keyboard (I, J, K, and L are mapped to up, left, down, and right, respectively) is something I'd miss. So I think Ted will still be useful for me. I may revisit this in the future though, and see if Claude could make a GUI version of Ted. That could be interesting.

I'll finish up by talking about some of the other features I asked to be added. Some of them were pretty ill conceived, as they came while I had a flurry of needs for CSV data. I ended up using to tool more frequently than I expected.

Sorting: Sort the table (the actual model, not just the view) either alphanumeric ascending, or alphanumeric descending based on the values of the current cell. There was also a "Sort Advanced" that prompted the user to enter the columns to sort in priority order (although not the direction, it's always alphanumeric ascending).

Match Cell: Select cells that had a value matching the current cell. This was an attempt of selecting rows to delete, but it never really worked well.

Set Where: Prompts the user for a source column, a set of match values, and a target value. Whenever the source column has one of the match values, it will set the current column to the target value. This acts like a poor man's inner join, and was made as I needed to interleave values I had from a shell command in the table I was working on.

PostgreSQL Docker and "No space left on device"

Fri, 06 Mar 2026 14:57:43 +1100

I was trying to launch a PostgreSQL Docker container and was seeing it fail with the following error:

initdb: error: could not create directory "/var/lib/postgresql/data/pg_wal": No space left on device

I checked my disk usage and I had plenty of storage left, almost half. Did an online search and discovered that Docker caps the amount of storage set aside for volumes. And that was set criminally low, about 119.21 GB or so, which is 6% of what’s available:

Raising the storage to 1 TB seemed to resolve the problem.

Kind of figured we’ve learnt from the issues with capping resources like this. Anyone who remembers the bad old days of adjusting the heap size of Java would surely get PTSD from dealing with this sort of rubbish. I know I did. I understand that for a shared instances or production setups, fair enough: cap the storage so it won’t go out of bounds. But for a standard laptop setup, just use all resources that’s available to you.

Anyway, if anyone else using PostgreSQL in Docker encounters this, try the method above. You can find it by opening Docker Desktop, then going to Settings → Resources.

Fri, 06 Mar 2026 10:22:56 +1100

Ooh, this is a nice new feature of Pocket Casts: the web player now includes chapter markers in the scrubber. You can mouse over them to get the chapter name, and click them to jump to the chapter.

Sun, 01 Mar 2026 16:58:06 +1100

How is it that people making screenshot mark-up apps still don’t understand that the blend mode for highlights should be multiply, not mix with alpha. A real highlighter would keep the text black, and won’t produce obvious overcoating. This just looks like I’m smearing yellow paint everywhere.

Devlog: Micro apps - Some Score Cards

Sun, 01 Feb 2026 10:05:02 +1100

In the spirit of maintaining a document of what I’ve been working on, and being somewhat inspired by Matt Birchler’s posts about his micro apps, I’d thought I’d document on some of the small apps I’ve worked on recently.

The fact of the matter is that I’ve been building quite a few of these apps over the course of the summer, primarily in response to a specific need I have at the time. I haven’t written about them before, mainly because there didn’t feel like there was much to say. Some were vibe coded, and saying that I “made” them didn’t feel correct. Others were made by hand, but they were super simple and there was no real challenge in making them at all. In either case, being able to say “I made it” is difficult as the amount of effort spent in making it is quite low, and that doesn’t make for interesting blog posts. Would a post saying that “I went to work today” be worth reading if that’s what I do every weekday?

But regardless of what my feelings are, the scales were tipped ever so slightly into wanting to write about them. So that’s what I’ll do. And there is some leeway in writing about the small things if I were to put them in the Devlog category, which could be seen as my public workbook.

So, let’s set expectations by talking about a series of score-keeping apps. These are among the simplest micro-apps I have, yet they do have their uses. You’re always left high and dry with a need to keep score of some ad-hoc game made in the moment (or, at least, I am). Notebooks and spreadsheets could work here, but I don’t carry a paper notebook, and use a digital notebook for this is always a little cumbersome. And a spreadsheet just feel a little overkill. Hence, the want for having a simple web-app for keeping scores:

Using it couldn’t be simpler: enter the score under the specific player, and it will be recorded in a table, alongside a running total. If you make a mistake, tap “Undo”. If you want to clear the scorecard, tap “Reset”. The scores are stored in local-storage so there’s nothing server side that’s running (although it does mean they’re tied to your browser). Focus automatically moves to the player to the right, but any entry could be entered at any time.

There’s a two player and four player variant. I was considering having a “player entry” screen to select the number of players, but that felt like adding too much complexity for something that’s designed to be quick to implement.

In fact, much of this was already implemented in the form of a Finska scorecard.

This is not a new project, I just moved it from a dedicated domain name and changed the styling. It’s been a while since I needed it for a game of Finska: I was more often than not using it for generic scorekeeping. But there were some aspects of scoring Finska which made it useful for that, and less useful for anything generic. For those who never played Finska, the goal is to get to exactly 50 points. If you go over 50, you go back to 25 points. There’s also a mode where all the zero point entries are highlighted to indicate a foul (3 fouls means you loose the game).

And, that’s it! Really, there’s nothing more to say about these apps. I had a need and some free time, so I put these together. There is one other scoring app that I’ve made, but that’s a little more complicated and warrants it’s own post.

Sat, 31 Jan 2026 10:38:13 +1100

More work on assets for my niece’s game. This time I tried something organic: a tree. Not the most difficult organic thing, I agree. Need to build up to the hard things.

Mon, 26 Jan 2026 09:36:01 +1100

Was not expecting to spend yesterday morning working on Dequoter, my Boop clone. Opened it up to do some light work and when I looked up, a couple of hours have passed. Added a few more processors to deal with lines, such as splitting and joining on commas. Added a status bar for processes that return information rather than filter text, such as returning a line count.

Also integrated UCL, because of course I did. Added two commands: a UCL: Evaluate which executes the input as a UCL script and displays the response in the status bar, and a UCL: Replace which replaces the UCL script with it’s output. This makes it possible to generate text from scripts, like a bunch of lines to test out the line count processor:

map (seq 20) { |n| "Line $n" } | strs:join "\n"

It’ll also make for a useful scratchpad for testing out some UCL commands.

Sat, 24 Jan 2026 11:22:43 +1100

Have finished a working version of my game for my niece. It’s only the free typing mode for now, which is essentially a basic text editor, with some colour options mapped to keys F1 through to F8. I’ve deployed a browser-based version of it if you’re curious.

Devlog: Game For Niece — More Art and Cropping Ebitengine Images

Tue, 20 Jan 2026 23:22:00 +1100

Drew some more artwork and started integrating it into the game. Replaced the previous bus image I got from an image search with one I created myself using Affinity Designer:

It’s orange, just like the busses round here, although this one has a plainer livery.

I’ve not integrated the car just yet: I’m hoping to finish off the animations for the bus first. But I’m so glad I embraced Affinity Designer for this. I’m surprise I haven’t considered it sooner. The whole image is designed as a whole, then I export each component — body, door, wheels — as a separate PNG and recompose it in the code, giving me the means of animating each component. I’d imagine this is a pretty typical workflow: and I’m surprise I haven’t considered this sooner too.

And yes, I will admit I did look at AI image generation for this. But I wasn’t happy with what it produced, and I wanted each image to have a consistent style. Turns out an “elementary vector artist” style works perfectly here.

Anyway, took a bit of time working out how to draw a cropped image in Ebitengine. Spent a little bit of time seeing what was possible with masks. But after looking at the examples, it looks like using SubImage for this is viable:

var busDoor *ebiten.Image = getSpriteImage("bus_door.png")

func render(screen *ebiten.Image) {
  doorDX := bp.sprBusDoor.Bounds().Dx()
  doorDY := bp.sprBusDoor.Bounds().Dy()

  pos := ebiten.GeoM{}
  pos.Translate(float64(doorDX/2), 0)

  screen.DrawImage(
    busDoor.SubImage(image.Rect(0, 0, doorDX/2, doorDY)).(*ebiten.Image), 
    &ebiten.DrawImageOptions{GeoM: pos})
  )
}

As for the other scenes I need to add, I plan to work through vehicles and objects first as they seem easier to draw. Hopefully by doing so I gain some practice before I tackle more organic objects like trees and animals. Tackling those feel a little daunting to me: more curves involved.

Sun, 18 Jan 2026 10:11:28 +1100

Well, would you look at that. Turns out I can draw… somewhat.

Rendering Outlined Text in Ebitengine

Sun, 28 Dec 2025 10:34:09 +1100

For anyone else using the Ebitengine that wants to render text as an outline, I’ve had had some success using the shapes package. The approach that worked for me was to render the text to a separate image, then call ApplyOutline using the screen as the target.

Here’s some very unoptimised code demonstrating this:

func (f *State) Draw(screen *ebiten.Image) {
    // The image holding the rendered text
    img := ebiten.NewImage(screen.Bounds().Dx(), screen.Bounds().Dy())

    // The filled in text colour. Here it's set to red.
    // As far as I can tell, this has no effect on the rendered outline.
    col := ebiten.ColorScale{}
    col.Scale(1, 0, 0, 1)

    pos := ebiten.GeoM{}
    text.Draw(img, "Outline", f.face, &text.DrawOptions{
        DrawImageOptions: ebiten.DrawImageOptions{
            GeoM:       pos,
            ColorScale: col,
            Filter:     ebiten.FilterNearest,
        },
    })

    r := shapes.NewRenderer()

    // Sets the outline colour to green.
    r.SetColorF32(0.0, 1.0, 0.0, 1.0)

    // Applies the outline. The numerical arguments are the 
    // x and y offsets, and the outline width.
    r.ApplyOutline(screen, img, 0, 0, 4)
}

If you want to render the filled in font alongside the outline, simply draw img to the screen before applying the outline:

screen.DrawImage(img, &ebiten.DrawImageOptions{})

r := shapes.NewRenderer()
r.SetColorF32(0.0, 1.0, 0.0, 1.0)
r.ApplyOutline(screen, img, 0, 0, 4)

Sat, 27 Dec 2025 10:15:38 +1100

Just placed the exit on Level 3-2 on my Godot game. The level still needs prettying up but the critical path is now done. I’ll think this will be the last level I build. There’s still so much work to do: polishing, backdrops, menus, etc. But no more content. Kind of want to put a pin in this one.

Thu, 25 Dec 2025 07:29:10 +1100

So this is what Christmas in winter feels like. 🥶

Sat, 20 Dec 2025 14:40:04 +1100

Trying out MB Manager by @timapple. Not bad. I like how snappy everything is. I also like the option for a serif font. Quite a unique way of reading Micro.blog.

Some Caution on Using ROWIDs for Primary Keys in Sqlite 3

Thu, 18 Dec 2025 16:24:21 +1100

I’ve noticed that relying on ROWIDs for primary keys in Sqlite 3 tables can result in IDs being reused. If you insert a row that is given a ROWID of 1, delete it, then insert another row, that second row will also be given a ROWID of 1. At first I thought it was just the Go port I was using, but I also tried a package that uses the C library and I observed the same thing. It’s reproducable using the sqlite3 CLI tool:

This shouldn’t be an issue normally, but I have been trying to enable foreign keys with cascade deletes in a program that’s using Sqlite 3. And maybe I’m not enabling them properly, but I’ve been finding rows that should’ve been deleted via this cascade were showing up in joins with new rows created on the foreign table. I don’t know why this is not working, but even so, having IDs that are never reused might be helpful here.

To avoid this, you can add autoincrement to the ID field to ensure that IDs are always monotonically increasing:

Apparently, this is not encouraged as it adds a bit of overhead to inserting rows. But if the price of unique IDs is a little more memory and CPU usage, for my teeny-tiny database, it’s worth it.

Fri, 12 Dec 2025 16:14:45 +1100

🛠️ Doom Text Generator

Looks like fun. Giving it a whirl:

Via: Martin Hähnel

Trying Out Pagefind in Micro.blog

Tue, 09 Dec 2025 08:21:24 +1100

Trying out Pagefind that was just released for Micro.blog. I find myself using the search on this blog surprisingly often, and while the search plugin has served me well, I’m always up for trying something new.

It took me a bit of time to work out how to get the actual search page. What I did was uninstall the search plugin, create a new “Search” page, and copied-pasted the sample UI on Pagefind’s docs. That worked without a hitch. I explored changing some of the display options, such as raising the number of results and the size of the snippets. Interestingly, a smaller number of results actually feels nicer. I started with 25 but seeing all those results felt overwhelming (who knew there was so much nonsense written here). I think I’ll give 10 a go.

If I can provide some feedback to Manton, it would be to choose which pages to index. I did a search for “Devlog” and found that the stats page, category list page, and various pages of the blog list were showing up in the results. It would be nice to configure the index to just the blog posts, maybe also the custom pages, and leave the entry lists out. I am curious to explore the capabilities of Pagefind some more, particularly around faceted search. One thing I’ve been thinking of for a while is the ability to use # to filter based on cataegories, such as #photos birds to return only the results with the “Photos” category. I did consider hacking this into the search plugin, but maybe I won’t have to.

All in all, I think I like it. I like how fast the results come through, and although I do prefer the UI of the search plugin, I think that’s solvable by tuning this one to my desires (or, just more likely, I’ll simply get use to it). I think this is a great addition to Micro.blog.

Devlog: Godot Project - Level 3-2 And Bobbing Water

Mon, 08 Dec 2025 22:32:32 +1100

I spent a lot of time on distractions recently, so I was a little surprised to find myself wanting to get back to working on that Godot game. The level under design is going okay: it took a few attempts to find the right way to start. Turns out writing down how you want the level to progress helps, like having three “acts” where the first act consists of some jumping puzzles, then introducing one of the gimmick, than a variant of said gimmick, and so on.

Anyway, I’m working on the second “act” which will feature a low-power mechanic: there’s only so many units of power to energise the various zones, and the player needs to juggle it all to get through the act. Because power is involved, I wanted to have a generator sprite to provide some decoration. This is what I came up with:

It’s… fine. I did try to get some inspiration by uploaded the tile-set to Google Gemini and asked it to produce something that resembled a generator:

Using the tile set images uploaded, please provide some suggested designs for a tile-set representing an electric generator. The suggestion must match the style and colour scheme of the supplied image.

This helped, although what I have here is a fair bit different to what was generated. I may adjust the colours a bit (the simple colours are by design as I want to maintain the palette used by the existing tile-set) and I may need to add some wire decorations and maybe a sign that says “Generator” to make it clear that’s what it is, and that it’s not a cannon, as the alt-text generation suggests. We’ll see how it goes, I guess.

One other thing I found myself wanting to add is water that can be raised and lowered when activated. I came up with something from first principals that looks a little like this (the tile layer is hidden to show the Area2D shapes):

It consists of is a top-level Node2D which will raise and lower when triggered. This is done in code, just to allow me to configure the speed and displacement on a case-by-base basis. A child of that is a TileMapLayer containing the water tiles. It’s at Z-index 6, which is just in front of the player so that it looks like it engulfs them if they fall in. Four units below the top is the kill-plane — water is a hazard — and four units below that is the “bobbing” plane. This is a Node2D that simply oscillates up and down by 2 units every second. A child of that is an Area2D solid with allows the player to move through, but will collide with a new crate sprite, which also collides with everything else.

This has the effect of a water plane in which creates would appear buoyant yet slightly submerged, giving the player somewhere to stand. Activating the water layer will allow it to “drain,” bringing the crates down to rest on any solids. Activate it again and the water level will rise, catching any crates which will begin floating:

There’s probably better ways to do this, and there are some drawbacks. It can’t be bundled into a dedicated scene, so each instance will need to be built manually. And if more than one crate is in the scene, they will bob in unison (although that could probably be alleviated with splitting the bobbing plane into areas with distinct offsets). But for something devised from first principals, I’m quite happy with it.

Devlog: Blogging Tools - Image Collections Triage App

Sat, 29 Nov 2025 10:54:02 +1100

Up until now, I’ve been using Blogging Tools’ in-app notification system to sort images to collections. There were quite a few limitations in doing so: only notifications for the first for images were raised, galleries weren’t handled, and you could only select one category per image. I also wanted a way to automatically change the header image in this blog. This was done using the image category notification, but it was pretty basic in that the image was chosen as the header if any category was selected.

I had ideas of improving all of this but I realised quickly that I needed something more sophisticated to do so. So I added another app to Blogging Tools to do this. I also thought to try out using Antigravity to do this. I was curious to know how well Google Gemini would work with a project that already had an established architecture and coding patterns. I was also curious to know how Antigravity felt when I held a tighter grip of the reigns: I wanted to drive the development work and only turning to the agent when I need something done.

I started simply enough: I built a basic HTML template for this new app and asked Gemini to prepare a stub handler:

Please create a new handler that services the template “imageposts/show.html”. Implement it much like the other handlers found in the “handlers” directory.

I forgot to mention to the agent that this was to be a stub, and it ended up using the existing provider for the gallery app. But it was pretty close to what I wanted. I then asked it to suggest a good HTML entity for opening a page in an external window.

What’s a good HTML entity for indicating that a link will open up into an external window/tab?

It suggested ↗, also a good answer. I then went on to build the Go models and wanted to work on the CSS styling next, so I asked Gemini to produce some example data using these models:

Please generate 3 stubbed values for this item slice. Use real example image URLs for the source.

It struggled a little on this one, suggesting a URL that didn’t exist. But after pointing this out, it got there in the end. It was at this point that I needed to do some refactoring to some of the existing services, needing to extract out a type that used only the values from another type. Gemini did quite well here too:

Note the select call. At the moment this is returning a micropub.Item model. I want to make a new model called “ImageCollection” that uses only the values of this micropub.Item that the code is currently using now. I don’t want the micropub.Item changed, but any code that is using this for the purpose of the selected call should include a map to this new model.

I guess this is not a novel experience to anyone using Cursor, but what I really liked about this interaction is that I was free to work on other things or move away from the keyboard entirely while the agent was working. This is one annoyance that I have with Claude Code: the exchange pauses and waits for me to approve every change before it proceeds. Having Gemini plan the changes first, then have me approve them once I’m back is a much nicer way of working.

I then turned to the database schema, defining the table schema and SQL queries myself, and asking Gemini to produce the Go code that marshals the data: the so called “database providers”.

Implement the Go DB provider for DB tables for the queries in “imageposts.sql”. Do it in a similar style to the other providers found in “providers/db”.

This is where I get the most use out of using coding agents. This code is not hard, but it’s super annoying to write. I think it also helps that there’s an established code base for the agent to work on. I was a little unhappy with what the agent produced last week, probably because it was required to produce it from scratch and in a way that wasn’t how I would write it. But here, probably because the agent had existing patterns to work on, it’s producing something that looks a lot better, to my eyes at least.

It did struggle with the providers a little, choosing to merge an update to two models in a single method. I did try to correct it, but I just had to go in and fix it manually.

We can probably separate SaveImagePost into one that saves the ImagePost, and another that saves ImagePostItems.

One other thing I discovered is that getting Gemini to write unit tests is important, as it provides a way for the agent to verify it’s code. I approved a change Gemini produced without looking too closely, and if I were to test it myself, it would’ve failed. But only after I asked it to produce a unit test did I see it fix the errors introduced in the last interaction. Something to think about in the future.

Might be a good idea to implement a unit test to verify that the DB methods in imageposts.go work. Do this by creating a new db.Provider instance with a temporary file, and verifying that the provider methods of imageposts.go work as expected. Please use testify.Assert to do the asserts.

It was now time to build the service layer. This is something I wanted to drive myself, occasionally relying on auto-suggestions. Antigravity fell down (ha ha) here a little, producing suggestions that were pretty far from what I wanted. I guess it was lacking the context to know what I actually wanted, which is somewhat understandable as I wasn’t giving that context. It also seems to fight with IntelliSence from VS Code sometimes. I occasionally press tab in response to a type suggestion from the index, only to have it produce a completion for some unknown type. I do wish the suggestions use the code index more in general. There’ve been more than a few times where the agent suggested types and methods that just didn’t exist. Might be something that can be tuned.

One quality of life improvement I did make was increase the timeout for when suggestions would appear. The default was something like 50 milliseconds, which is pretty short. Bumping it to 1 second helps, but even so they still get in the way. I may bump it a little higher.

First cut of the collection triage screen at the end of day one.

I worked on this feature over the next couple of evenings, occasionally changing tack which required a change in the database schema. One thing I did like while working on this was getting to the point where I could simply ask the agent to update the provider code whenever I did so, and it knew what I meant:

The ImagePost model and table schema now has a PostDate field/column. Please update the providers.

I do get the feeling that the user interaction in Antigravity needs to be refined a little. For someone who is willing to do most of the driving, it would be nice if the editor was a little less “needy”. This is probably more to do with VS Code being the underlying editor: lots of annoying popups and mouse overs, all shouting for my attention: LOOK AT THIS, LOOK AT THIS. But the AI suggestions don’t help. Instead of displaying the generated code, disrupting my sense of where everything is, maybe a more subtler approach is warranted: a small indicator beside the cursor or in the margin indicating that a suggestion is present. I may miss it, but who cares? Remember, I’m the one driving here.

Today, I got the feature finished. The way it works is that it will poll the RSS feed of this blog, and for every post that has an image, it will add an entry for me to triage. Each entry consists of a brief summary, plus the images found within the post:

A new 'Sort Image Posts' app, with a badge indicating the number of images to triage.

List of posts with images that need triaging.

Clicking through to the post would list the collections, and I would select the ones I’d like the image to be filed in. And this would list all the images of the post, not just the first few. It is all or nothing, unfortunately. There are ways to get the images of the collection, but I couldn’t see a way for me to get the collections of an image. I don’t think this would be a problem, as Blogging Tools is the only way I actually set the collections of an image.

Selecting a post will list the images found within that post, with the collections they should be added to.

Saving the categories will queue the changes, which will be applied every 5 minutes. A first cut of this feature applied the changes immediately, but the way I imagine using this is that I’d go in, triage the images in one go, then leave. Applying all the changes then felt inefficient.

When it comes to setting the header image, I figured I’d add a dedicated collection for that. Every hour a cronjob will query the local database for images that is within this category, and write the URLs to a manifest file in the assets Git repository. A Forgejo Action on that repository runs every night, and will check the date-stamps for the next image to display on the header. If one is found, it will fetch the image, save it as a JPEG with reduced quality and upload to Netlify. Since Netlify flushes the CDN whenever a deployment happens, nothing more needs to be done: no MD5 sum hashes, no adjustment to CSS files. Just update header.jpg and go:

// Example of the manifest file.
{
  "images": [
    {
      "date": "2025-11-22T13:00:00Z",
      "url": "https://lmika.org/uploads/2025/pxl-20251120-083552448.jpg",
      "crop": "bottom"
    },
    {
      "date": "2025-11-26T13:00:00Z",
      "url": "https://lmika.org/uploads/2025/a3c74bfebd.jpg"
    }
  ]
}

Deployed all these changes to prod and naturally some rework that’s needed. First, I completely forgot about galleries. They do come through as image tags in the generated HTML, but I’m operating on the source post, and they appear as Hugo short-codes. Fortunately the way I write galleries is pretty standardised now, so I think a regular expression would work here.

var (
  galleryRegexp = regexp.MustCompile(`[{]{2}[<][ ]?glightbox.*src="([^"]+)".*[>][}]{2}`)
)

Oh, I also want to fix the layout of the collection checkboxes and hide some options, such as those that for past years. And finally, will turn off the existing image category notification logic.

Deployed again, and now I just need to wait for the next time I post a photo. I suspect some bug fixes or usability adjustments will come from this, but more on that when that happens.

Mon, 24 Nov 2025 17:03:04 +1100

Three nuisance calls today so now call screening is being turned on. I think this feature deserves a “finally.”

First Impressions Of Google Antigravity

Sat, 22 Nov 2025 14:03:33 +1100

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.

Devlog: Laying The Groundwork For Dynamic Header Images

Sat, 08 Nov 2025 12:11:26 +1100

Making some changes to the Card theme I’m using for this blog. First think I’m considering is a banner image, similar to the one in Scripting News. And like Scripting News, I’m hoping for the image to change occasionally. I’d like the change to happen when the blog is being built, and in order to do this, I need a way to configure this value. I’m hoping to use Blogging Tools to do this, but to actually make use of these values, I’m hoping to use Hugo’s resource data methods.

The idea is to setup an assets project which will be hosted on Netlify. When I want to change anything in it, Blogging Tools will push new changes via Git, which will run a pipeline that will deploy the updates to Netlify. Then, next time I add a blog post, Hugo will pick up these data fields and use it to build the site, probably by setting an attribute that will itself be picked by CSS’s newly improved attr() function to set the banner background.

This will start off as simple data values, stored in JSON, which will include things like the current banner header. One of the reasons why I’m keeping the actual data separate is that I don’t want any issues with Blogging Tools from impacting my ability to publish blog posts, and I have more confidence in Netlify’s ability to keep a service up than I do, especially as a company that is getting paid to do so.

Being a “backend guy”, I’ll start on the Netlify and Blogging Tools side of things first. Actually, I’ll start on the asset repo first, just so I can verify that Micro.blog’s Hugo instance can pull data like this.

I’ve added the new Git repo and got it publishing to Netlify on commit to main. At the moment there’s a single JSON file, /site/data.json that has a test message. The goal is now to get that onto my test blog and included in the Hugo template on build. Naturally, because Hugo loves changing their public API so often, I need to see how this is done in Hugo 0.117 as it seems to be completely different in Hugo 0.141, the current version as of this writing.

So, checking out the Hugo source code and doing a find/grep search to find the relevant technique. Turn’s out the way to do this in Hugo 0.117.0 is to use the getJSON function. Here’s a link to the docs for anyone else who’s interested.

<div>
  {{ $siteData := getJSON "https://assets.lmika.org/data/site.json" }}
  <div>My data is {{$siteData.data}}</div>
</div>

Okay, that seams to work:

So, the next thing to do is to add a banner image. I’m thinking of a slightly washed out version of the image, with a subtle gradient to the body housing the cards. I had to adjust the header template a little to move the site-header to a wrapping div. This allowed me to add new CSS to allow the header to span the entire width of the page. It’s really fortunate that the Card theme styles the CSS classes, and not the HTML elements themselves. It also allowed me to add a new HTML element with a header-end class to act as the gradient blend from the backing image to the regular background colour:

<!-- Template: layouts/partials/header.html -->
<header>
  <div class="site-header">
    <!-- The original content of 'header' -->
  </div>
  <div class="header-end"></div>
</header>

With that I could restyle the header:

/** Header */
body {
  /* The body had a 10px padding which I had to disable to allow
     the header to blend all the way to the client sides. */
  padding: 0;
}

div.page-content,
footer.site-footer {
  /* Disabling the 10px padding on the body meant I had to move
     the padding here.*/
  padding: 10px;
}

header {
  /* Using 'background-blend-mode' to mix the header image with the background
     colour. We're using 'color-mix' to make the background color slighty
     transparent to do this. */
  background-color: color-mix(
    in srgb, 
    var(--body-background-color),
    rgba(255,255,255,0.75)
  );
  background-image: url(https://lmika.org/uploads/2025/c1745b14d3.jpg);
  background-blend-mode: screen;
  background-size: cover;
  background-position: 50% 50%;
  margin: 0;
}

div.header-end {
  /* A small gradient from transparent to a fully opaque background colour
     allows a smooth transition from the header to the body. */
  height: 20px;
  background: linear-gradient(180deg,
    rgba(0, 0, 0, 0) 0%, 
    var(--body-background-color) 100%
  )
}

Various links to MDN documentation covering all these changes:

background-blend-mode to blend the header image with the background colour. This is to wash it out some so that the menu items are not illegible.
color-mix to set the transparency on the background colour.
linear-gradient to generate a linear gradient.

Oh, and I naturally forgot dark mode, so added a new style to darken the image in that mode:

@media (prefers-color-scheme: dark) {
  header {
    background-color: color-mix(
      in srgb, 
      var(--body-background-color),
      rgba(0,0,0,0.5)
    );
    background-blend-mode: darken;
  }
}

Okay, the next thing is to make the image dynamic. I want to try and use CSS attr() to do this. Basically the idea is that when the template is built, the image URL is pulled from the data and sent to the CSS via a HTML attribute. Here’s the new header template

<!-- Template: layouts/partials/header.html -->
{{ $siteData := getJSON "https://assets.lmika.org/data/site.json" }}
<header data-background-url="{{ $siteData.header.imageUrl }}">

And the updated CSS:

header {
  background-image: url(attr(data-background-url raw-string));
}

Ah, that didn’t work. Apparently there are some restrictions on attr which could potentially result in security issues. So, plan B is to simply set the background-image in a style a style attribute:

<!-- Template: layouts/partials/header.html -->
{{ $siteData := getJSON "https://assets.lmika.org/data/site.json" }}
<header style="background-image: url({{ $siteData.header.imageUrl }})">

Okay, that’s working. Now the final test: can I make it dynamic? I’ll change the URL to another image:

{"header":{"imageUrl":"https://lmika.org/uploads/2025/pxl-20251105-200617867.jpg"}}

And publish a new post to rebuild the template. Let’s have a look:

Awesome, that’s working. Now to apply it to the actual blog. I did make one last change: the header attribute is used for the header of posts too, so I had to add a class — site-header-wrapper — to only select the site header. But yeah, it looks good. I like it. For reference, here’s the final template changes I’ve made:

<!-- Template: layouts/partials/header.html -->
{{ $siteData := getJSON "https://assets.lmika.org/data/site.json" }}
<header class="site-header-wrapper" style="background-image: url({{ $siteData.header.imageUrl }})">
  <div class="site-header">
    <!-- The original content of 'header' -->
  </div>
  <div class="header-end"></div>
</header>

And the final CSS changes:

/** Header */
body {
  padding: 0;
}

div.page-content,
footer.site-footer {
  padding: 10px;
}

header.site-header-wrapper {
  background-color: color-mix(
    in srgb, 
    var(--body-background-color),
    rgba(255,255,255,0.75)
  );
  background-blend-mode: screen;
  background-size: cover;
  background-position: 50% 50%;
  margin: 0;
}

@media (prefers-color-scheme: dark) {
  header.site-header-wrapper {
    background-color: color-mix(
      in srgb, 
      var(--body-background-color),
      rgba(0,0,0,0.5)
    );
    background-blend-mode: darken;
  }
}

div.header-end {
  /* A small gradient from transparent to a fully opaque background colour
     allows a smooth transition from the header to the body. */
  height: 20px;
  background: linear-gradient(180deg,
    rgba(0, 0, 0, 0) 0%, 
    var(--body-background-color) 100%
  )
}

I didn’t have time to integrate this with Blogging Tools, but the groundwork has now been laid for that now.

Devlog: Dynamo Browse - Item View Annotations and Asynchronous Tasks

Tue, 04 Nov 2025 21:42:40 +1100

The laundry list of things to do in Dynamo Browse has grown over the last week, as I find myself wanting using it and wanting more from it. I’ve knocked off many of the small ones: fixing bugs, making it easier to get the first item from a result set. The time has come to tackle some of the larger ones.

The first is the ability to annotate fields in the item view, as in add additional information to the right of the value. I would personally find that useful for describing the value of an other table using it’s ID. But the point is that it can be anything. I’d like users to add these annotations via extensions, using UCL. The way I’m thinking of doing this is by “installing” a field annotator, something along the lines as follows:

ui:add-item-annotator { |rs attr_path| 
    return ""
}

This will add an annotator which will take a result set, and a path to an attribute. It will return the annotated value. We’ll see how well this will work, but first I’ll need to build the Go types. Rendering the item view is done using an ItemRenderer which basically walks through the attributes of an item and renders it as a table. I think I’ll change this to take an item annotation. I also realised I need a type to represent the attribute path. I think a simple linked list would work here. Here’s what I got:

type AttrPathNode struct {  
    Name    string  
    Index   int  
    IsIndex bool  
    Parent  *AttrPathNode  
}

The trouble is representing both string attribute names and numerical indicies in the same type. Go doesn’t have a great way of doing this, so I’ve gone with something simple and added boolean which would be true if the node is actually an integer index to a list or set.

Actually, that may not be necessary. Poking around the renderer code, I found this type used to represent the sub items of an item:

type SubItem struct {  
    Key   string  
    Value Renderer  
}

So I can simply use strings for the key. Good to know. Okay, added a test annotator and gave it a quick test: Not bad, although found some glaring issues. It would be nice if the annotation was closer to the value. And laying out the annotations in a dedicated column will cause the entire column to shift as I move through the items. So instead of making it a separate column, I’ll try simply concatenating it to the end of the value. I’ll also apply the meta-info styling to dim the text a little: That’s much better. I’m banking on only a few attributes having annotations, so I’m hoping it won’t be as busy as it looks here.

Now to consider the UCL integration. Hmm, how am I going to connect the two? As expected, injecting the annotation directly into ItemRenderer would introduce a dependency loop. What I could do instead is add a setter allowing the caller of the ItemRenderer to change the annotation on the fly, and inject the ItemRenderer as a dependency of the command controller.

Implemented this, and it was actually easier than I thought. Now to test this. I settled on the following UCL command:

ui:set-item-annotator { |rs item path| 
    "annotation"
}

where:

rs is the result set
item is the item being rendered in the view
path is the attribute path, represented as a list.

The attribute path is a new proxy, just to reduce the amount of memory copying between Go and UCL. I kept the same list index semantics, where > 0 starts from the left, and < 0 starts from the right, but it was a little mind bending to reverse this for a linked list.

A simple annotator which returns the currently displayed item value as an annotation can be implemented as follows:

ui:set-item-annotator { |rs item path|
    $item.($path.(-1))
}

Here it is in action: Brilliant, it’s working! Naturally as commands are simple UCL statements, this could be entered on the command line.

One thing to consider is that unlike normal commands, the UCL block rendering the annotation is running on the UI thread. Not sure I like this, but the amount of effort required to change this would be significant. I guess I’ll just tell everyone to keep annotation rendering fast. And as it’s currently implement, it is reasonably fast. Or more accurately, it’s not noticeably slow, which is good enough.

The next feature to add to Dynamo Browse is a way to asynchronously schedule blocks. I think it may be worth tapping into the existing command looper in some way.

Commands in Dynamo Browse are invoked on a dedicated goroutine. Calling execute() will attempt to send a command via a channel. If that fails, execute() will return an error indicating that a command is currently running. This keeps running UCL code off the UI thread, and it also makes it possible to implement commands like ui:prompt synchronously from the UCL code’s perspective, when in reality it pauses this goroutine and sends a message to the UI with a callback to resume the thread:

func (m *uiModule) uiPrompt(
    ctx context.Context,
    args ucl.CallArgs,
) (any, error) {  
    var prompt string  
    if err := args.Bind(&prompt); err != nil {  
        return nil, err  
    }  
  
    resChan := make(chan string)  
    cancelChan := make(chan struct{})  
    go func() {  
        commandctrl.PostMsg(ctx, events.PromptForInputMsg{  
            Prompt: prompt,  
            OnDone: func(value string) tea.Msg {
                resChan <- value  
                return nil  
            },  
            OnCancel: func() tea.Msg {  
                cancelChan <- struct{}{}  
                return nil  
            },
        })  
    }()  
  
    select {  
    case value := <-resChan:  
        return value, nil  
    case <-cancelChan:  
        return nil, nil  
    case <-ctx.Done():  
        return nil, ctx.Err()  
    }  
}

So tapping into this event loop would be nice. But how does one do so?

I think, probably the simplest way to do so is with buffered channels. These are bounded, meaning that there will be an upper limit to the number of pending tasks, but maybe that’s not a bad thing. Having too many pending tasks crowding out the user’s ability to run commands will probably make for a poor user experience. So let’s set the limit to something quite generous, say 50, and integrate it into the event loop:

for {  
    select {  
    case cmdChan := <-c.cmdChan:  
        res, err := c.ExecuteAndWait(ctx, cmdChan.cmd)  
        if err != nil {  
            c.postMessage(events.Error(err))  
        } else if res != nil {  
            c.postMessage(events.StatusMsg(fmt.Sprint(res)))  
        }  
        if execCtx.requestRefresh {  
            c.postMessage(events.ResultSetUpdated{})  
        }  
        // New code here
    case task := <-c.pendingTaskChan:  
        if err := task.task(ctx); err != nil {  
            c.postMessage(events.Error(err))  
        }  
    }  
}

Now for the UCL API. I have an idea of adding a new async package for this, which will provide commands for running things asynchronously. It’s simplest command would be async:do, which will schedule a block when the command loop is free. So invoking the following:

ui:command testasync {  
    echo "This"
    async:do {
        echo "Other"
        async:do { echo "Sierra" }
    }
    async:do {
        echo "Romeo"
    }
    echo "That"
}

Should display:

This
That
Other
Romeo
Sierra

In the logs. Trying it out and here’s how it looks: Okay, that’s pretty good. Now to build on this. The next thing to add is a command that will schedule tasks in the future, similar to window.setTimeout(). For this, I plan to use the gocron package. Lots there, but for my purpose, I plan to use the OneTimeJob type. It does feel like bringing in a crane to lift an empty wood pallet, but the alternative is building my own scheduler (or getting AI to vibe-code one) using a heap. Maybe something for later, but I think this is fine for now.

To make use of this, I’ll add async:in, which takes a timeout in seconds, and a block to run. To test this, I’ll do the classic “count down” tests:

proc countdown { |from|
    if (le $from 0) {
        echo "Blast off!!"
        return
    }
    echo "$from"
    async:in 1 { countdown (sub $from 1) }
}

ui:testasync {
    countdown 10
}

Here it is in action:

One last thing to add to async, the ability to run a query in the background and execute a block once the results are available, keeping long running queries off the UCL goroutine. I think for this I will add another thread-pool which will execute up to two queries in the background, then schedule a task to run once the results are ready.

The API for running queries is pretty well established, to the point that I’ve actually got a helper functions which deal with the UCL side of things, so it’s just a matter of implementing an asynchronous version of this. I’m thinking of an interface along the following lines:

async:query <query> { |rs|
    # do something with the result-set $rs
}

It should also support keyword arguments too. Unfortunately, UCL requires keyword arguments to be placed after the positional arguments, so they would need to be placed after the block, which is a little yucky.

Implemented the code, now for the test. This one’s a little contrived. What it does is asynchronously run a query on startup, counting the number of opened and closed offices in the business-addresses table. Once those results are available, it will install a new column annotation, which will display the count to the right of the officeOpened fields.

proc _prep_officeCount {
    openedOffices = 0
    closedOffices = 0

    async:query 'officeOpened=true' { |rs|
        openedOffices = len $rs
        async:query 'officeOpened=false' { |rs|
            closedOffices = len $rs

            ui:set-item-annotator { |rs item path|
                if (eq $path.(-1) "officeOpened") {
                    if $item.officeOpened {
                        "Count = ${openedOffices}"
                    } else {
                        "Count = ${closedOffices}"
                    }
                } else {
                    ""
                }
            }
        } -table business-addresses
    } -table business-addresses
}

_prep_officeCount

It is contrived, but I’m hoping to use this in a real setting where I annotate ID fields with a value I retrieve from another table, so a use case like this is pretty close to why I built this feature. Because the queries are running in the background, the goal is to avoid blocking the UI thread, but since this runs on startup before the user selects a table, the table needs to be specified as part of the call. I may have to have a think of how I am to fix that.

But here it is working. Note the Count = 244 next to the officeOpened field:

Excellent. The next thing to do is try this out in a real setting. I finished off making a proper goroutine pool for the task that actually runs the query — which I’m calling the “aux task pool” — and a few other changes, like making the meta information a little easier to see.

Devlog: Godot Game - Level 3-2 and a Rotating Platform

Tue, 28 Oct 2025 22:19:28 +1100

Okay, time to start level 3-2. This, like level 3-1, is in the mountainous regions. Except this time, the player will be a little higher. So that means jagged platforms, more verticality, lots of gaps: a real sense that care of where one steps must be taken.

Starting with some platforming to give this sense: a few narrow safe areas, separated by pits, leading into an area with platforms.

Now, I have two choices of mechanics here: I can have the rotating platform, or I can have an area of the tile map fall away when the player lands on it. I think I prefer the rotating platform for the sole reason that adding the falling away platform may be a little overwhelming for the player.

Actually, no. Danger and instability is the feeling I want to go for here. So I’ll add the falling platform, followed by a large safe area where the player can see the rotating player. Also, since this is a new mechanic, it’s only right that the player should play with it in a safe area first.

Okay, I’ve added the falling platform. Well to be honest, I designated an area of the field where the falling platform will go. This leads into a large safe area which would be an ideal place to introduce the rotating platforms I have in mind.

I’m thinking of a scene with an AnimationPlayer that will do the actual rotation animation: as in rotate the sprites from 0° to 90°. The question is, do I want the entire sequence timed using the AnimationPlayer? As in, have a single animation that will rotate the platform all 4 times, with gaps between each stage? Or should I stick with the AnimationPlayer simply animating a 90° rotation, and having another thing timing the wait time between stages?

I think I prefer the latter. That way, I have more control over the pause between stage rotations. I can do things like disable it, or making it configurable. All desirable features.

I guess the next question then is whether I want the AnimationPlayer at all. Wouldn’t it be more flexible to do the animation in code? Probably, but I’m not sure I want that flexibility, at least not yet. Maybe in time it would be needed, but I think for now, I’ll just stick with the AnimationPlayer.

So, let’s start building out the animation. I think I’ll start with four animations, each one rotate the platform from θ to θ+90°, just from different starting positions. I’ll use names that include the start and end angles, like rotate_0_to_90, to allow for bidirectional rotation, should I decided to add that. Angle 0° will be up, and rotation will be clockwise. I think each rotation will be 0.5 seconds at speed 1, just so I have a consistent speed control. I can adjust the speed of the overall playback on the AnimationPlayer itself.

Okay, animations made. Now to think of collision. I don’t like the idea of a collision box rotating along with the platforms. I’m not too certain about how well this plays with the physics engine, and even if there were no issues, non-orthogonal geometry is just not a thing in this game. So what I’m thinking of doing is adding two collision boxes, one horizontal and one vertical, and just toggling between the two as the platform moves into position. While the platform is rotating, both boxes will be turned off.

Ooh, I didn’t know the collision layer could be added as a animatable track. That’s pretty cool.

Now to add a Timer which will actually dictate the cadence. The included code is nice and neat: basically take the current rotation of the sprites in degrees, add 90 to it, and produce a string which will become the next animation to play:

func _on_timer_timeout() -> void:
	var next = _next_animation()
	animation_player.play(next)

func _next_animation() -> String:
	var rot = int(sprites.rotation * 180 / PI) % 360
	return "rotate_%s_to_%s" % [rot, rot + 90]

Added it to a test level, and I had to speed up the AnimationPlayer to 3x normal speed, just so that the movement is snappy enough to justify the loss of collision during the rotation. It may need further adjusting a little later, but so far works pretty well. Although I do think I need to telegraph when the platform is about to move.

Oh, I remember how I’m going to telegraph to the player when the platform is about to rotate! It’s to be an indicator panel mounted at the front that will rotate slowly on it’s own. When it reaches a new orientation it will pause, then the platform behind it will rotate.

Okay, new sprite. How the heck did I choose a canvas size with non-even dimensions and still end up with a sprite that doesn’t have a definitive centre line? 🤦

Turns out it was how I was removing the upper and lower circles. I was using the eraser for that, and I didn’t position it properly.

Okay, here’s the sprite:

Now to think about animating it. I’m wondering if it would be possible to simply add it to the same animation player as the platform. The thing is, I would like them to be somewhat independent. The indicator should move on it’s own accord, even when the platform sprite is rotating to a new orientation. I would also like the indicator to take on the platform rotation cadence, sending it a signal when it reaches a stop (this will remove the need for the Timer).

Can I do that all in a single scene though? Maybe with two animation players? I’ll try that and see how viable it is.

Okay, just tried that, and yes, using two AnimationPlayers is viable. Now to prepare the animation. The current rotation period is 3 seconds so I’ll start with a 6 second animation that would just rotate the indicator over 180° with a slight pause halfway to trigger the platform. One good thing about the indicator’s symmetry is that one animation can cover the full rotation. Although be sure to change the loop wrap mode to “Clamp”, otherwise you’ll see the sprite spin round to 0° when the animation repeats.

Here’s the full thing in action. And yeah, adding the indicator was pretty crucial in the end. The platform wouldn’t have been fair otherwise.

Mon, 27 Oct 2025 12:56:16 +1100

Discovered that turning off “Convert pasted HTML to Markdown” in Obsidian has eliminated the need to select Edit → Paste and Match Style when pasting things from the terminal to a note. So glad this setting exists. One more of those things I wished Obsidian had, and sure enough… 🫲 🫱

Sat, 25 Oct 2025 09:11:35 +1100

Anyone remember jQuery Mobile? Looks to be live and well on Tram Tracker. First time I actually noticed it, as I usually don’t have a need to visit the website.

Fri, 24 Oct 2025 21:14:35 +1100

My eye has been wandering towards the Cards Theme of late. It was enough of a pull that I decided, after a couple of schooners this evening, to switch this blog over to it. The Mythos theme is good, and the changes I made to the index page to display posts in a similar way to Scripting News was an interesting experiment, but I don’t think it fit the type of site I wanted. I’ll give the card theme a try and see if it’s a better fit for me.

Wed, 22 Oct 2025 17:45:19 +1100

Whew! Made it home. A bit of a delay but given the strong winds, it’s fortunate that the commute wasn’t longer than it was. Could’ve been much worse. Good thing that large tree branch didn’t fall on the train line (it was close enough to brush against the side of the train).

Devlog: Godot Game - Working On Backdrops

Mon, 20 Oct 2025 22:01:17 +1100

Time to focus on backdrops. Aaaaargh! What it’s time for is to face my inability to make artwork. I’ve been able to do small things: lifts, signs, even some pickups. But for the larger stuff, I don’t know where to begin. And regretfully it fills me with shame that I’m even looking at asset packs: despite most of the assets in this game already originating from an asset pack. But the alternative is drawing it myself. And I’m not confident that I’ll be able to do a good job here.

But let’s try. If it doesn’t work, I’ll use the asset pack.

The first idea is to get some inspiration. Well there are plenty of those in my photo collection. Here’s one that seems like a good start:

In short, foothills are slightly jagged yet mainly consist of sweeping curves at roughly the same vertical height. Colour and shadow provide the sense of distance. The hills in the photo are largely covered in vegetation, which could potentially be simulated by a vertical spray-brush: favouring light and dark green with some light brown on a largely mid-level green colour.

Also I need to remember a principal of illustrations: go from the foreground to the background. I guess one saving grace with modern art tools is that I’ve got layers to play around.

Okay, new sprite. Let’s start with the foothills. Taking inspiration from both the photo and the asset pack. Tracing around the foothills and adding some colour to give us depth yields the following:

Okay, not bad. A little plain but a good first start.

Trying out some ridge-lines.

Ugh, that looks awful! Not convincing at all. Okay, forget about the ridge-lines. I also tried out adding a spray to simulate vegetation but that didn’t look convincing either. I think given the distance, my skill level, and the fact that this is a backdrop, less might be more here.

Let’s try it out in the game. I’ll use the existing blue sky image I have for the desert world. Let’s also remove the existing backdrop.

Hmm, the issue is trying to get the hills to look convincing, and given that the player starts quite high, and given that the camera is position to track the player near the centre of the screen, they won’t see this background layer. But this might be okay as I also need to make a distant mountain layer too.

Okay, after a lot of trial and error, I’ve got the foothills positioned in a way that works well:

In order to do this I had to do the following:

Scale them down by 50% so that they don’t dominate the screen or have too large pixel edges.
Use a horizontal scroll offset of 0.7 and a vertical scroll offset of 0.2 so they look convincing in the background. I did try a vertical scroll offset of 0.0 to keep them anchored at the bottom of the screen. But because of how the camera follows the player vertically as they jump, that just looked disorientating.

A few things I’ve learnt about using Parallax2D: you want the “repeat size” to be the size of the sprite (after transforms) so that they’re laid out seamlessly across the screen. If the scaled size doesn’t make it all away across, bump the “repeat times” up a few times. You will get the automatic repeat, which you can verify during play through by overriding the camera, zooming all the way out, and turning on 2D controls:

Now it’s time for the mountains. For this I’m going to use this asset pack for inspiration. Obviously much taller than the foothills, with jagged peaks. Less sweeping curves, and more like upside-down Vs, yet with flat tops.

Here’s attempt one:

No, don’t like it at all. For one thing the canvas is too wide in the vertical direction and too short in the horizontal direction. For another, the mountains don’t look convincing. The peaks are too pointy. So what I’ll do is cut the canvas in half and try again with a steadier brush.

Here’s attempt two:

A little better. The general shapes look okay. Might look better after colouring it in.

Okay, here’s the mountain layer with the colouring:

It’s almost convincing. Let’s try it out in the scene.

Hmm, I’m not sure I like it. It looks a little cartoon-ie, what with it’s large, sweeping areas filled with a single colour. I also don’t like the outlines: they’re a little too bold. It may help if I made the mountain layer a little smaller and reduce the motion a little.

Okay, after doing that, I like it a little more. The outlines are less pronounced and you see the more of the mountain plate throughout the level. I added back the outline in the foothill plate. I think you can either go with outlines, or you go without: mixing the two looks bad.

I’ll try this for a while. I may play around with the scroll settings a bit but it is difficult coming up with a combination that will show the mountains for more of the level while also hiding the seams between the layers. I may need to adjust the contrast a little, just so that the background doesn’t clash with the foreground: even in the screenshot about it’s a little muddy. I also need to put in a cloud layer too. Not quite sure how I’ll make convincing looking clouds, but I’ll think of something.

Tue, 14 Oct 2025 21:51:47 +1100

Finally added some checkpoints to level 1-3. Also added some animated water as a new type of hazard. The asset pack I’m using came with a single “wave” tile. I used Aseprite to shift that across 4 cells and configured it as an animation in the tile set. I was planning to add some background waves too, but that made it a little too busy and hard to discern. Less is more here.

Mon, 13 Oct 2025 22:02:13 +1100

A small devlog entry today. Just painting the level, adding background tiles and kill-zones. I also added a frame around the lift door, just to define it a little. Discovered that it’s probably best not to have sprites with non-even dimensions. It makes positioning them a little awkward, resulting in fractional offsets. I elected to include a transparent row at the top of the frame sprite, just to avoid this.

Devlog: Godot Game - A Trigger That Reveals Secrets

Sun, 12 Oct 2025 11:09:40 +1100

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: Godot Game - More on Level 3-1

Sat, 11 Oct 2025 21:10:10 +1100

Starting on the Godot game again. Level 3-1 is nearing its finish. I’m building the corridor/cave that’ll lead to the lift that the player will travel up to the exit. To add some interest, I’m terminating the corridor at a spike section which should be impossible for the player to navigate. But now I’m wondering: what if the player managed to navigate this with invulnerability? Maybe a secret where the player picks up a vile given them this power that would allow them to travel through this section and pick up something nice?

I’ll come back to that. I’ll build the lift first and give it a try to see how it feels.

Need to remember how these lifts work. Okay, yeah, it’s all driven by the doors. Added the lift and gave the level a test from the midpoint. Feels good. I do like the lift. I jumped around the spike section a little and yeah I think something like a secret allowing the player to travel through that section for a bonus would be nice.

First implementation of the invulnerability power-up: simple enough. The current implementation taps into the existing death handler, in which an Area2D trigger will signal to the player to die when they enter a trigger area. Note that this happens when the player enters the area. If the player is already in the area, nothing happens. This means that if the player enters an area, and stays there when the invulnerability power-up times out, they’re still invulnerable until they exit that area. A way around this is to constantly signal to the player to die while they’re inside, but I think I’ll keep it this way for now. I like the idea of giving the player just a little more time than they have to be invulnerable (although when they leave and enter a new kill zone, they will die).

Okay, implemented the invulnerability power-up and gave it a quick test in the spiky area. Yeah, it works. I haven’t added the kill zones yet so the need for invulnerability is completely unnecessary, but the progress bar has been implemented, and based on how quickly that runs down, there’s ample time for the player to get the pickups and get back before the bar runs out.

Place the exit and now just playing through the level. It needs checkpoints, and there are some tricky jumps that I’m tweaking. But I think it plays rather well. I’ll start dressing up the level now.

Fri, 10 Oct 2025 09:17:26 +1100

Some advice for the TLDraw Obsidian plugin maintainer: drop everything after the words “and” and “then” in these menu items, then remove duplicates. This should bring the menu items down to a number that’s easy to scan. I can manipulate tabs myself, but finding what I want here is a lot.

Devlog: Godot Game - More On Level 3-1

Thu, 09 Oct 2025 22:19:54 +1100

Working on the Godot game again. Finishing off the top layer of zone 3 in 3-1. Made a floating balloon with a smaller drop-payload trigger area, just to avoid accidental triggers if the player gets too close.

One thing I didn’t appreciate is that if the player misses a jump, it takes a long time for them to fall and recover from that. I’m wondering if I need to add some kill zones between each horizontal level of the cross-back, along some checkpoints so that the player doesn’t have to spend so much time waiting to fall and redoing large chunks of the zone.

I’ll try this will some barbed-wire graphics. See how I feel about it. Here’s how they looks:

Doesn’t look inviting, although that’s kind of the point. But this may work as a kill-zone between hight levels. Although I’m uncertain as to how I’m going to introduce them to the player. Maybe they won’t need any introduction: some ugly, spiky coils might be deterrent enough.

Anyway, the elements of the actual jumping part has been filled in. I think adding this was a good idea: feels interesting again. Now it’s just a matter of adding the final lift, and then the exit.

Devlog: Godot Game - More On Level 3-1

Wed, 08 Oct 2025 22:07:17 +1100

Continuing the build out of the zone 3 in level 3-1. I’ll start with a platform that is self rising when the player jumps on it. Always a classic; and honestly, I think the start of the level can use that. Lift does feel a little slow. I boosted the speed from 70 to 90. Also started added floating balloons with mines around this part of the level, since those elements were introduced in zone 2.

Hmm, I wonder if I should make a variant of the red balloon with mine. The mines will kill you, but the player can safely land on the top of the red balloon. I’m wondering if a variant that is unsafe for the player could be useful. Maybe a “spiky balloon” type. It can be attached to the grey mine I made for level 2-2.

Alternatively, I can make it a different colour and just make it such that landing on it will pop the balloon. Took a brief look at a colour blindness test and it looks like red and green is the way to go for two distinguished colours.

Hit a roadblock: I need to import a type, the TextureVariant enum, from one script (the static mine) into another one (balloon_with_static_mine). Quick web search and it looks like the way to do this is by “preloading” a script. This gives you access to the script’s symbols:

const StaticMine = preload("res://scripts/static_mine.gd")

@export var mine_texture_variant: StaticMine.TextureVariant

To support popping when the player lands on it, the balloon is an AnimatableBody2D which can detect collisions as it bobs up and down. I wonder if I can actually test collision that way:

var coll = animatable_body_2d.move_and_collide(velocity)
if coll != null:
    if coll.get_collider().name == "Player":
        print("Bang!")

No, turns out I can’t. Tried this and even played around with layers a little, and it didn’t detect when the player landed on it. So moving to plan B, which is adding an Area2D set to layer 2, the same layer as the player. When the player lands in that, it will pop the balloon… eventually. At the moment it just makes the balloon disappear. I’ll need to add the pop animation and sound effects. It will also give the player a jump at at about the same distance they would travel in a normal jump.

Okay, new variant implemented. Here’s how it looks:

I was going for something a little deadlier, but I think having the extra jump could make for some interesting mechanics. I guess we’ll see. Anyway, I’ll leave it there this evening. I’ve managed to get 2/3rds of new section built out.

Devlog: Blogging Tools - Podcast Clip Favourites

Mon, 06 Oct 2025 22:29:36 +1100

Back on Blogging Tools. Gave up on trying to set a remote ref: all the ones I’ve tried were not working. Looking at the examples it looks like I can call Push with defaults (apart from authentication which looks like I’ll require with my repo). Gave it a try and that looks like it worked. I peeked in the source code and the default ref that work was the following:

DefaultPushRefSpec = "refs/heads/*:refs/heads/*"

Turns out by adding refs/remote/origin/… I was using the default pull ref. I suppose I should learn more about how Git works in this respect. But later, it’s working now. That’s all I need. Finishing off the Blogging Tool side of things by moving all the hard coded values to the config, and I think this is ready to go.

Turning to the Hugo site. I’ve started a new site from scratch, which does little than just push to Netlify. Same template and same changes I’ve made for the test site. I don’t love the template, but I think it’ll work for now.

Created a new site and installed the theme. Set the menu and cleared the footer as per this Hugo config:

baseURL = 'https://example.org/'
languageCode = 'en-us'
title = 'Podcast Favourites'

theme = 'hugo-flex'

[params]
footer = ""

[[menu.main]]
name = "Clips"
pageRef = "/about"
weight = 1

[markup.goldmark.renderer]
unsafe = true

Produces this nice clean home page:

Added CI/CD to build the site and deploy it to Netlify. All seems to work.

Merge changes in Blogging Tools, pushed to Forgjo, and redeployed in Coolify. Status is degraded. Reason is that the temp directory, which is where the workspace for the Hugo site’s Git repo, doesn’t exist:

I forget that this is deployed in a scratch container, which has no guest OS. So creating the /tmp directory is something I’ll need to do. Will add a quick bit of logic to Blogging Tools to do this prior to creating the Git provider.

Actually, no. Change of pace. I’ll do it in the Docker file. What I’ll do is touch a file in /tmp during the build phase and just copy it over to scratch (I can’t do this in scratch as it doesn’t come with executables). This should force the directory creation.

RUN touch /tmp/t
    
# ---------  
FROM scratch  
  
COPY --from=builder /tmp/t /tmp

Redeployed and… what?

Oh, that’s meant to be:

COPY --from=builder /tmp/t /tmp/t

Copying directly to /tmp makes a new file with the filename tmp in /.

Okay, Blogging Tools is working again. Let’s try it out.

Ah, error: author field is required. I need to set this for the commit call. That may be why the commit author was me and not the bloggingtools user when I was testing this on my own machine.

Trying again. Hey, success! Blogging Tools added the clip to the repository and pushed the changes as the bloggingtools user. This kicked off the CI/CD to rebuild the Hugo site and pushes it to Netlify. Did forget to fix the base URL add the Hugo template for making the audio playable, but fixed that and now the clip is playable.

Nice! Calling this feature done. I will need to style the Hugo site, but I’ll do that over time. It’s getting a bit late and I want to wrap this up.

Devlog: Blogging Tools - Podcast Clip Favourites

Sun, 05 Oct 2025 17:52:30 +1100

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.

Sun, 28 Sep 2025 12:09:06 +1100

Small change to the thirst mechanic for my Godot project. Switched from discrete thirst levels to a single timer that will tick down if the player is thirsty. This allowed for a change to how I indicate this to the player, replacing text messages that’ll be displayed at each thirst level with a gauge that shows up on the HUD.

I thought that the messages would be enough, but after playing through with them, they turned out to be more of a hindrance. They didn’t communicate the player’s thirst level well enough: they show up for a few seconds, then disappear, leaving the player to wonder how much time they have. This information is now always present with the gauge. Plus, I think it gives more of a sense of urgency, in that a gauge that’s constantly ticking down will encourage the player to play a little faster in order to reach the next water bottle before they perish from thirst.

Sat, 27 Sep 2025 12:02:07 +1100

More on that Godot project today. Finally bit the bullet and started working on proper backdrops. I’ve leaving the artwork until later (i.e. I’m procrastinating), today was all about the mechanics, trying to get parallax scrolling working. Fortunately Godot has built-in nodes to make this easy, although I did have to upgrade Godot to 4.5.

This is my first cut, some simple colour banding to represent sky and sand in one of the desert levels:

These two layers were added to the scene as Parallax2D nodes, each with a single Sprite child. Positioning the sprites was a little tricky. Godot suggests placing them at the origin, but what I didn’t understand was that the actual position of the sprite depends a lot on the scroll scale of the Parallax2D node. I added the sky layer without changing the scroll position and it took me a while before I discovered that it was appearing below the camera. Only after reducing the scroll scale to about 0.1 did it start showing up in the viewport (one nice thing about Godot 4.5 is that the “play scene” window includes debug options, allowing you to hijack the camera and move it around the scene).

I will need to introduce some detail in the backdrop layers soon. The bands are too simple and may induce some vertigo when the player is ascending to high platforms. Plus, it just looks boring. Not that they’re meant to be eye-catching but something a little more interesting would be nice.

Sat, 27 Sep 2025 10:41:49 +1100

Just a reminder that MacOS comes with a grapher, and a pretty decent one at that. Came in handy when I wanted to visualise a few functions.

Devlog: Trying OpenAI Codex to Produce Freelens Logo Creator

Sat, 13 Sep 2025 10:05:30 +1100

Tried a bit of vibe coding using OpenAI Codex yesterday.

I needed something to produce nice logos for Freelens so I can tell each cluster apart. The default avatar for Freelens is an abbreviation of the cluster name set atop a random background colour, which doesn’t do me a lot of good as the cluster names I work with are all similar, and would produce the same abbreviations. Furthermore, Freelens doesn’t have a way to change these default avatars. But it does have a way to upload new avatars as an image.

This was a perfect candidate for trying out OpenAI Codex. A use-case that I needed but was not important nor interesting enough for me to build manually. I mean, knowing me, I probably would’ve built it, but it wouldn’t have been good use of my time. So I created a new Github repo, connected it to Codex, and gave it this prompt:

I would like a static web-page, consisting of one HTML file, and one JavaScript file. This is to be vanilla JavaScript that does not require NPM or any external dependencies.

This page is to have a form which accepts the following input:

A text input with the name “Upper” which accepts a string of any kind.

A text input with the name “Lower” which accepts a string of any kind.

A selection for background colour. Instead of a colour picker, please allow the user to select one of 8 distinct colour choices. Each one should be distinct enough such that the user is able to distinguish them from each other. They should be of medium darkness, such that if white text were to be display atop of it, the text should be legible; yet not too dark as to be hard to distinguish.

The page is also to have a canvas element, of about 80 x 80 points, which will take input of the form above and do the following:

Fill the background with the chosen background colour.

Draw a thin dividing line — no greater than 6 px wide — in white across the width of the canvas.

Print the form value of “Upper” in uppercase, in a san serif font, centred and above the dividing line in white. The printed text should be large enough to fill most of

Print the form value of “Lower” in uppercase, in a san serif font, centred and below the dividing line in white.

Ensure that a suitable margin of 15 pixels padding around the border of the canvas content, and that the printed text and dividing line is not drawn beyond the margin.

The canvas element is to be updated when the form values are changed.

Below the canvas should be a button which should allow the user to download the canvas image as a PNG.

And here’s what it produced:

It pretty much did what it said on the tin: when I changed the value of upper or lower, or changed the background colour, the canvas would redraw showing a different preview. Clicking “Download PNG” would allow me to save it as an image.

On the whole, what I received was pretty good. It’s not perfect — there’s no styling; orange is a bit too close to amber, as is green and teal; and the alignment of the bottom line is slightly off. But it’s a pretty decent start.

There were some things I wanted to change, so I went in myself. I found a nice looking stylesheet called Pico CSS, which I’ve applied. Normally I would’ve turned to simple.css, but I’ve been using that a lot and I wanted to try a nice, fresh look. I also adjusted the vertical positioning of the lower row in the icon, added support for single line icons, and adjusted the colours a little.

The whole thing looks quite nice now, and I’m quite happy with the icons it produces:

I’m still working out how these AI coding agents will fit into my life. I’ve been using Claude Code occasionally, and that’s been a good fit for projects where I’d prefer to be the driver. But there are occasional things that I’d like to see exist but are a little too trivial to spend the time on. In those cases, I may not have built it at all; or I would’ve built it and then immediately regret spending the time doing so it. And that might be where Codex could be useful: it provides a good starting point, which I can then refine.

If you’re interested in trying this tool out, you can find a link to it here. The source you can find on GitHub.

Tue, 09 Sep 2025 08:41:44 +1100

Finally indeed.

Sun, 07 Sep 2025 12:14:00 +1100

Ah, MacOS’s locked-down nature strikes again! Was testing the CI/CD build for Dequoter and after downloading the artefact and attempting to open it, I got this warning message:

Turn’s out it was being quarantined by MacOS, and these instructions resolved the issue:

xattr -dr com.apple.quarantine '/Applications/Your Application.app'

The binaries not notarised so I wasn’t expecting it to work out of the box. I was hoping that it would do that thing where the app will be listed in settings and I can allow it to launch from there, but I guess there’s something about where this file came from that was too much from MacOS. Ah well, I can live with this for the short term.

Sun, 07 Sep 2025 11:21:44 +1100

Speaking of Dequoter, in “celebration” of the upcoming release of MacOS 26, I styled the command palette a little, adding a transmissive blur to give it a glass effect:

It’s a shame I can’t style the options of the select element. It would be nice to increase their margins a bit.

Devlog: Dequoter — Something Different Today

Sat, 06 Sep 2025 17:10:04 +1100

When it comes to hobby projects, I’m trying to reduce the number of things I build for work. But I’ve decided to revisit one that I’ve abandoned, given the frequent need for this. The issue is simple: I have a JSON data structure that is quoted within a string, and I want to “unquote” it and filter the JSON so that I can read it.

So I thought I’d spend today restarting the Dequoter project. The best way to describe it is a Boop clone. I like Boop, I use Boop. And I know Boop is extendable, so I could implement any processor I need using JavaScript. But I’m not a huge fan of JavaScript, and Go has the function I need right there in the standard library. And with most things I encounter, I want to build my own. I know I shouldn’t, and I’ve been better at resisting. But I’d figured this could be a nice little distraction. And I thought I could get much of what I need done in a morning.

So I started a new Wales project and after about 3 hours, I had a scratchpad with an invokable command palette that I can use to dequote a string and format a JSON object:

Granted, it’s not much for 3 hours. While I did use Claude Code a little, much of this was hand rolled. And I spent a lot of time learning the ins and outs of Code Mirror. This is why I wanted to use Wales this time around. The previous run at this used Fyne, which was really nice to use, but the available widgets were quite limited. The nice thing about Wales is that I can build the UI in HTML and it uses the built-in HTML renderer from the OS: no need to bundle Chrome. The frontend is mainly vanilla HTML and JavaScript, although I am using Stimulus to help with some of the controls. The backend is, of course, Go.

Final build size is 8.4 MB.

By the end of this morning’s session, what I had was not pretty, but it’s functional and it already does what I need it to do. I do have some plans for integrating this with UCL, and using that to define processors. That should hopefully leave all the heavy core stuff to be built near the beginning, and that could sit pretty while the extensions are added in a nicer language. Anyway, more on this if this goes anywhere.

Fri, 05 Sep 2025 12:15:05 +1100

I saw someone online mention Zo Computer so I though I’d give it a try. Asked it to produce a Go function based on one of my blog posts, since I needed the same thing in a different project. I saw it open the blog post and generate the function in about 5 seconds.

Granted that this is hardly groundbreaking. It’s using GPT 4.1 mini, so it’s likely I could’ve done the same thing straight from ChatGPT. But I think it’s a good first step in seeing what this service is capable of.

I also wonder if the model is actually consuming the post. I have nothing to support this other than doubt that the post would be in GPT 4.1’s training data. The URL can’t be more than a month old.

Wed, 03 Sep 2025 22:27:26 +1100

Starting to work on the background tiles. This is what I have so far. I hope it’s not too busy or distracting.

Tue, 02 Sep 2025 13:31:59 +1100

What is this?

A UI for ANTS?! 😼

Tue, 02 Sep 2025 08:58:28 +1100

It’s not unheard of to have animals, usually kangaroos, on our line near the down end where it’s quite bushy. But this is well within the inner city. I wonder what it could be. 🤔

Devlog: Godot Project — Bricks in Level 2-3 Laid

Mon, 01 Sep 2025 22:31:56 +1100

Just a quick update today. I’ve finished all the brickwork in level 2-3. And it didn’t go too badly. Made one significant mistake which would’ve involved a lot of rework, that I patched up with some single tiles:

Top: the mistake. Bottom: the fix.

Doing the rest of it was pretty dreary work. Godot does have some tools to make this easier, but there was no getting around the level of care needed to place the bricks correctly. But it’s all pretty much done now. And just for comparison to the before screenshots I took when I started, here’s how how the level looks now:

There’s still plenty of work. The background is not yet done, nor are any of the pickups placed. The HUD needs updating to show the key gems the player has, and I also need to repair some dodgy mechanics around moving platforms. But I guess that’s just a matter of plowing ahead.

Devlog: Shutting Down Nano Journal

Sat, 30 Aug 2025 16:34:43 +1100

With the move to Obsidian for my journalling needs, I shut down my bespoke journalling web-app. I deployed it on 26th August 2024, which makes it just over a year old. I did start using Obsidian on the 20th though, so it didn’t quite make it the entire year. Even so, not bad for something hand made and somewhat neglected. Most things I eventually abandon last way less than that.

Anyway, here are some screenshots of the final version, just before I shut it down:

The landing page, with a full-width post text area.

A post with attachments.

Clicking 'Posts' will bring up a chronological list of posts from the last 6 months. Those with a paperclip are ones with attachments.

An example of a viewing a post. Attachments would appear below the body.

You can compare this with some earlier screenshots documented in these posts:

22 August 2024: Development work started
15 September 2024: Addition of attachments and titles
4 October 2024: Adding Git synchronisation of entries

I guess you can describe the ascetics of this project as the “minimum amount to get working.” That was true of the backend too, which was somewhat rushed and difficult to maintain. That might be why I never really gave this a lot of love as other projects like Blogging Tools. But I added some features I that I thought were neat: such as attachments, and keeping a copy of a draft in the browser’s local storage before it was sent to the server.

Anyway, I’m now in the middle of migrating the old posts over to Obsidian. One thing I’m glad I added was Git synchronisation. And given that entries were plain markdown files, migration was simply a matter of checking out the repository and moving the posts across. Easy enough work, although I am taking my time. There’s a bit of reliving involved with moving the posts over, and I’m approaching a period where some pretty sad things happened.

Anyway, that was Nano Journal. Good at what it needed to do.

Devlog: Godot Project — Level 2-3 Update

Tue, 26 Aug 2025 23:27:58 +1100

Been working on level 2-3 these past few weeks. And it’s a large one: 4,720 x 2,928 units. There are longer levels but those tend to be quite horizontal, unlike this one which feels like a mixture of the two dimensions:

Reached a milestone this evening: the critical path has been built. And yeah, it ended up pretty much being a standard key-hunt. I did have an idea for having more puzzle elements, like requiring the player to work out combinations based on key colour, but given the length one has to travel to get the necessary keys, it felt like a hit to the pacing. I figured it would be more interesting to vary the mechanics in each zone the keys are located. They’re not complicated mechanics, but they did reach the limit of what I had in my toolbox. It got to the point where I started adding the classics, like dart shooters which fired projectiles.

Pick up these gems…

…and place them on this holders to activate things. And yes, I stole this directly from Commander Keen.

Given that this is in the desert world, the sand spinners make an appearance.

The new dart shooters and the projectiles they fire.

There are a few mechanics I wanted the player to learn. Trying to telegraph that via gameplay is not easy, but I’m hoping it will comes through. Some approaches I’m trying are slight cues in colour and making sure interaction indicators are clear. And also level geometry, such as moving the player through one-way gates and making it obvious that all they have to proceed is right in front of them.

I’ve also decided to move away from paid checkpoints, where you need to pay 5 coins to save your progress. I’ve replaced these with hidden checkpoints, of which this level has a few. I think given the size, and that some backtracking is involved, it makes more sense being quite generous with checkpoints in this level. I think I’ll keep the 5 coin toll gates though for other things.

Work remaining on this level is prettying it up (it’s still rather barebones) plus adding pickups and maybe some bonuses. Painting in the brick tiles will take a while, but could be a nice exercise in calming work when one can switch off their brain somewhat. I also need to make the background tiles and (ugh) the actual level backdrop. Not quite sure what that will be. Something deserty no doubt.

Fri, 22 Aug 2025 10:19:30 +1100

It’s always something with NPM, isn’t it:

Here’s an idea: why don’t YOU rename that directory, NPM?

Devlog: Blogging Tools — All About Images

Sun, 10 Aug 2025 22:30:40 +1100

I’ve been working on Blogging Tools on-and-off the last few weeks, mainly around images and image management. They’re not super exciting in their own right so I’d figure I’ll briefly write about them here.

The first major addition is the ability to save images to the server from the Image Tool app. There are some composition processors available and if one wanted to pre-process the image in some way, they would have to download the pre-processed image and upload it again for composition. This change will hopefully reduce the need for this back-and-forth. The download button has been replaced within the Image Tool app with a Save button, which will upload the processed image to the server.

Saved images can be recalled from the processor by using a new picker. This replaced the Load image by URL option, which I never really used (although I may add it back within the Saved Image app).

There is also a new Saved Images app which allows one to browse the saved image, file them into categories, and download them to the local file system.

Now those with keen eyes may notice the quality of the saved images in the screenshots above. That’s because the second change I made was to integrate calls to an image generator. There was no reason for doing this other than to try out the API, and I haven’t really used it for anything other than make test images. The API I’m using is Flux 1 provided by together.ai, but there’s also a partially-functional version of Gemini’s API too (the API is region locked and is not available in Germany, which is where Blogging Tools is running).

Saved Images are build on the existing Files subsystem, which has been relegated to a new Settings section, the third change I’ve made to Blogging Tools. This allows one to manage files, see running jobs, and managed sessions from the system. That section may expand in time as I think of things I’d want to change without redeploying the app (most of the config is managed using environment variables).

The last change was the addition of a new notification type. I’ve added photo collections to my blog a few months ago, but I never remember to actually file photos into any of them. My workflow with making a photo post usually ends at the point I hit “publish”, and as far as I can tell, there’s no way to set the category of the image from the new post screen.

So I’ve added a new notification type to help me with this. When the RSS feed of my blog is polled, and a new post with the “Photos” category is found, the first 4 images are extracted and presented as a notification asking if I want to file the photos into a photo category.

This also worked for posts you add to the “Photos” category via the notification subsystem itself. Both act on the same RSS feed and setting the category of a post to “Photos” will clear the fetch history of that item so that it can run through the processors again.

I’ve decided to use notifications for this, rather than add something to do this automatically, as I do want to go through the candidate photos first. But there are some limitations to this approach. For one, the notification system only allows one user selection per notification, making it impossible to add a photo to more than one collection. And to keep the number of notifications low, only the first 4 images are presented, with the rest being ignored. I have some ideas of how this could be improved in the future — probably by adding a separate app — but for now, I think I could live with taking corrective action manually.

One last think about this new category processor: it’s activated by a change to the RSS feed, but it scans for images using the original post retrieved from Micro.blog’s micropub API. The reason for that I’ve enabled the CDN option, and the image URLs which use the CDN do not work with the collections API. It took me a while before I figured this out, mainly because I wasn’t using a CDN on my test blog and that worked perfectly. Something to keep in mind for anyone else using this API.

Thu, 07 Aug 2025 08:05:39 +1100

I gotta say, I’m not digging this white-on-white button motif in Liquid Glass. It looks buggy and unfinished. A little dated too: it reminds me of the late 2000’s when box-shadows were added to CSS 3 and websites were experimenting with using shadows as borders.

Kicking the Tyres of Ollama's Native App

Wed, 06 Aug 2025 17:43:00 +1100

I’ve seen a few people online talk about the new Ollama native macOS app. I’ve not used Ollama’s CLI tools myself, and have very limited experience with running models locally. I think I tried a couple of years ago, and gave up at the step when they asked me to setup a Python virtual environment. Since then I was always under the impression that setting up LLMs to run locally would be painful, and while I liked the idea of doing so, it wasn’t enough to go through that pain again. So hearing about Ollama packaging all this in a native app piqued my interest, and I thought I’d give it a go.

Install was as expected: just download a DMG and add to Applications. I was half expecting the package to be huge to accomodate the models, but the download doesn’t include the models themselves, which is fair enough given that there are a few to choose from.

First launched revealed a very ChatGPT-esk experience, making it absolutely clear how this app worked. I poked around a little trying to find the place where I can download a model, but I couldn’t find anything. I then tried posting a question and quickly found out that models are downloaded on demand.

It was then a matter of trying out some of these models. First test was with Gemma 3:4b. I asked it a question around the tongue-twister “see shells sea shells by the sea shore”. The fact that it actually produce a result was impressive, yet the quality of the answer was questionable:

For comparison, here’s the same question posed to ChatGPT:

So this model struggled a little, probably because it was on the small size (I’m assuming the “4b” refers to the number of parameters. 4 billion?). I didn’t get a good gauge as to how slow the response was. It was slower, but not as slow as I was expecting. Plus it was coloured by the time it took to download the model, which itself was not fast (maybe 30 minutes to an hour, although I wasn’t on a fast connection).

I then tried the same question with Deepseek R1:8b, and was greeted with a reminder that this is not a Western trained model. But after some clarification it got there in the end. Ollama actually displayed the reasoning steps as the model was going through it’s inference, which is a nice touch.

I could go on and try Qwen 3, but you get the idea. This is not really about the models (okay, it’s sort of about the models, but I’m hardly putting them through the paces).

So on the whole, I found the app itself is quite pleasant to use. The minimal aesthetics make it very approachable for someone who only had experience using ChatGPT. I also like that you can go back through your chat and edit past questions. Being able to “alter the context” like this is something I wish the online AI chat apps support, particularly when the model start going down the wrong path.

At the same time, I do wish I have a bit more control over the experience. I’m not a user of Ollama’s CLI tool so I don’t know what’s possible but some things I would like to see added down the line:

A way to manage model downloads outside of the chat window.
A way to configure the system prompt. I actually don’t know if Ollama’s applying one, but if it is, it would be nice to see/modify it.
A way to export the chat transcript.

So, would I continue using this? Honestly, probably not, mainly because of performance. I’m not sure the computer I’m using (a 2020 MacBook Pro M1 with 16 GB RAM) is powerful enough to be competitive to the online models. Maybe if I had the latest and greatest hardware, with as much memory and significantly more disk space, it would be a viable contender. I do have access to something a little newer (Mac Mini M2) so I maybe I’ll try it out there. It would be interesting to see how the OpenAI’s new open weight models, which were release while I was writing this, will perform.

But that said, I’m quite impress that I was able to run these models at all. I have heard of others running local models for a while now, and I like the Ollama makes this easy to do so, with a nice, approachable native app.

Moving TIL Computer To Quartz

Mon, 04 Aug 2025 23:49:57 +1100

Moved TIL Computer over to a new technology stack. Yes, again. This frickin’ site, and it’s spiritual predecessor, has seen a few tech stacks transitions recently it’s surprising that I haven’t significantly lost anything (apart from the post dates). The main reason is that I can’t decide if this should be a blog or a wiki. The site contains the accumulation of lessons learnt and other bits of knowledge acquired as part of my software engineering job, so having a way to quickly access something is moderately important. The pages themselves are relatively long-lived, and somewhat evergreen, so there’s not a huge temporal access: one could argue that an RSS feed would be unnecessary. However, I do want that buzz from seeing something I publish show up in an RSS reader, so one would be nice. Hence the reason why this site was principally a blog for most of it’s existence.

That’s why my interest was piqued when I saw Jessica Smith’s post on how she moved her site to Quartz. After some investigation into Quartz’s features, including how well it works with Obsidian, it seemed enough of an improvement to try out.

So I took an export of the old site, previously hosted on Micro.blog, and imported the markdown files into a new Obsidian vault. It was also an opportunity to finish fixing up the posts that were still encoded in HTML from the previous export, which I didn’t get around to fixing when I imported them into Micro.blog:

The home page, which posts listed in reverse chronological order.

An example of a post.

Another post. I will admit I will miss the fonts used in this template.

The archive. The categories would go on to be the top-level folders in the Quartz site.

The search, which is actually quite good.

These cheatsheets never really developed into anything. The goal was to concatenate a collection of titleless posts into one large page. But I never got round to building the template for that, which meant I never wrote any posts that would fit that model.

The Obsidian vault was then added to a Git repository, which’ll get pushed to my Forgejo instance when the site is to be republished. Doing so will run a CI/CD pipeline which will download Quartz, prepare a new workspace, copy the Obsidian vault into the “content” directory, copy the config and layout files, build the site, and then push it to Netlify. This is probably not the recommended approach, but I’m very interested in making sure the Git repository is as close to the original Obsidian vault as possible. I plan to relay on Obsidian and it’s vault sync for writing the site’s content, so anything that could be done to avoid disrupting that is welcomed.

The layout isn’t too far from the default, apart from some light changes to the colouring, font, and layout. I already like the wiki-style sidebar on the left, which would make finding things easier. The fact that I was more-or-less limited to reverse chronological posts list was one of the downsides of the blog-style approach (well, that’s not entirely true: I could’ve adjusted the template to be more wiki-like. I just never got around to doing so).

I also simplified the information design a little. The original idea I had was to separate guides from references and “cheatsheets,” a post type that was never really defined well. But I found that I preferred just lumping the posts into folders sitting at the top-level based on the technology. Pretty unsophisticated, ’tis true, but given that there’s only around 60 pages there, I think it’s just enough to know where things are while keeping things simple. I’m also hope to use the search more often, a feature Quartz comes with out of the box.

The new Quartz site, showing off the current… let's say… 'minimalist' index page.

An example of a page. One thing I do like about this template is that a table of contents will appear on the right if the window is wide enough.

Selecting a top-level folder will reveal the contents. I believe this is customisable, but this will do for me now.

The search interface. Looks a little busy, but it definitely works. I would like to hook up a hot-key to open this up eventually.

I may need to adjust the fonts a little more, and I am thinking of hooking up a hot-key to trigger the search box, but so far, I’m quite pleased by it. Granted it’s only been a couple of days, and I still have the backups of the old site if I want to back to this being a plain-old blog. But I think the Obsidian integration plus the more wiki-like architecture will suit this site better.

Oh, and one last thing: it’s been almost a year that that site has been up, and good news: I don’t hate the name. That was the issue I had with it’s spiritual predecessor, and it got to a point where I wasn’t motivated to write on it anymore. I don’t have any of these feelings with this name. Nor do I hate the idea of writing technical stuff there and everything else here. I know this is not a concern for anyone else, but for a few years I struggled with the idea of keeping two separate sites and where things should go. With having a place to keep my technical knowledge separate and in a format that’s easier to navigate, I think those feelings are at rest.

Sat, 02 Aug 2025 09:16:22 +1100

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.

Wed, 30 Jul 2025 11:14:06 +1100

🛠️ Obsidian Plugin: Daily Notes Editor

Displays all your daily notes in a single editor tab, much like Roam Research. This was a feature I liked about Roam, and when I first looked at Obsidian, I wish it had it. Trying it out on my personal vault, where the daily notes tend to be quite small.

Some First Impressions of iPadOS 26 Public Beta

Sun, 27 Jul 2025 08:44:23 +1100

Upgraded my iPad to the iOS 26 beta, just to see what this fuss over Liquid Glass was about. First impressions after about 30 minutes of use: hmm. Certain aspects about it do look nice — I like the effect it has on the launch bar and when moving an empty app folder over the changing background. And I can see what they’re trying to achieve. But there are some aspects I’m not too sure about.

The glassy lettering style for the time on the lock screen makes it harder to see at a glance. Likewise for notifications with the glassy background. Both give the impression of something being there as long as you look carefully at the edges. It reminds me of that episode of Seinfield where Kramer found a windscreen on the road and thought to make a coffee table from it, with the other characters expressing skepticism that they wouldn’t be able to see it (“you’ll sense it”).

Another thing I’m not to sure about: the lack of definitive edges between colours in app icons, like the Photos app. They now make them look a little blurry from a distance, at least to my eyes:

Might be okay if all the icons were like this, but at this stage, when you compare it to an icon that has not been updated, like Obsidians, it just looks weird:

I don’t like what they’ve done to Safari either. The header is now taller and the address bar is now shorter. Shortening the address bar actually bothers me quite a bit. I don’t know why they had to do that, it’s not like they’re short on space. Granted I’m using Safari in landscape mode, which is how I generally use my iPad, but it’s not like the address needs to be the same size in both orientations. And it’s not like they don’t know how to do this: they did it in iOS 18.

Oh, and ahh, yeah: contrast bugs in Safari’s header are still a thing:

Finally, popup menus in Safari: when you bring them up for a picker, the menu shoots off from the button to the right and then resizes to left to reveal the options. This feels buggy to me, or at least I hope it’s a bug as it’s a transition animation that I don’t care for. For something that I expect to just drop down, there’s a lot of unnecessary moving about.

So yeah, first impressions are kinda mixed. I can now understand what the Apple pundits I listen to are talking about. And I do get the sense they may have bitten off more than they can chew here. Hopefully they can improve on this before the general release.

Devlog: Godot Project — Level 4-2 And Level 2-3

Sat, 26 Jul 2025 16:47:11 +1100

I can’t quite remember how far I got into building of level 4-2 when I wrote my last Dev Log entry. Based on how I described it, I think I was still working on the bones of it: a level with little more than the tile-map. I got a fair bit of the level built since then. It now features three major zones, each with a different camera lock. The central mechanic of a tile layer that can be raised by hitting switches has been built, along with it’s variations within each zone. Pickups and enemies have now been placed. And decoration. A lot of decoration.

I wish I had a screenshot of how it looked when I wrote that last entry, but here’s a shot of how it looks now:

I’m quite happy with how the mid-layer tiles add some interest to the aesthetics. But while thinking of the actual background to set the scene, I now feel that simply adding sky-coloured tiles is not enough. I may need to make a proper landscape backdrop, for no other reason than to give the level some place. Not entirely sure how I’m going to do that.

Anyway, that’s for later. For now, I had another go at working on world 2. Level 2-1 is still barely started: I haven’t returned to it yet, and probably won’t until I have an idea of how to put that level together. I do have some ideas for level 2-2 and 2-3 and to ease myself in working on them, I started the week by simply building game elements, like a thirst mechanic (world 2 is a desert, as pre-ordained by Yahtzee Croshaw). More on those in the future I’m sure, but it was enough to get me to start work on level 2-3, which I’m thinking might be set in an underground pyramid with some windy maze elements (original, I know). Not too many windy maze elements, mind you: I generally don’t like playing maze levels. But I think a little would add some variety to what I’d imagine would be simply jumping puzzles until then. So far this has meant reverting to “playing the hits” as it were, by starting off with adding a simple lock-and-key hunt, albeit with gems (shout-out to my fellow Keen 4-6 fans). I do have a twist in mind which I hope to slowly introduce to the play as they progress through the level.

I’ll just finish this update off with some screenshots of how level 2-3 looks now in it’s super early state.

So that’s where things currently stand.

Wed, 23 Jul 2025 09:02:22 +1100

Since I’m not a huge user of iCloud, the fact that I only have 5 GB doesn’t offend me. But seeing the breakdown of my storage usage, I can understand why people think Apple is being unreasonable here. To use up 80% of the available storage and leave a measly 1 GB for personal use is not great.

Wed, 23 Jul 2025 08:55:14 +1100

Logged into the iCloud web-portal for the first time today (I completely forgot that there was a web portal). I don’t know if this is a thing many people use, but it’s… okay. A little slow, but potentially useful for those times when you can’t access something via native apps.

There is also a sense that it’s a little flimsy, that if you push too hard it will fall over. Can’t quite put my finger on why that is, but I think it’s all the small, thin fonts and pale colours. Just feels a little fragile.

Mon, 21 Jul 2025 09:50:02 +1100

Kind of wished Mail.app kept your email rules when you choose to sign out of iCloud. I did just that on my work laptop, and today I found all my rules got clobbered. Good thing I documented at least one of them, so I didn’t loose too much. But it’s still data loss, and I rather it didn’t happen.

Devlog: Blogging Tools — Category Fixer

Mon, 21 Jul 2025 00:09:07 +1100

I was going to say that this one was pretty quick to implement, but thinking of it now, it took several hours all up, so maybe it wasn’t that quick. It’s a feature I’ve creatively called the “category fixer”. Yeah, the name’s not great, but it’s been a feature I’ve been wishing for a while, and it’s nice to see it added to Blogging Tools.

I post blog posts of images which could either be a photo or a screenshot, along with the occasional meme. I have categories for all three, and when I create a new post with an image, I try to make sure the appropriate category is set. Only issue is that I usually forget, and most image posts remain without any category at all. Micro.blog does has a feature of automatically adding posts with image tags into a photos category, but I’ve turned that off as I don’t like the idea of screenshots going there.

So I needed a way to fix this, and that’s what this new feature does. I’ve added a RSS feed parser which will poll my blog’s RSS feed for any new or updated posts. If there are any, the HTML content will get parsed to find at least one img. If it does, an in-app notification will be added. I can then go in and triage these posts, selecting the category they should be sorted into.

The in-app notifications, accessible from a new top-level menu item.

Tapping the disclosure icon reveals the first image found, along with a link to view the entire post.

Selecting an option will update the notice then and there (using HTMX). The notice isn't cleared until the category change has been made, which does require a page refresh.

About half the work was building out these in-app notifications. They’re all stored in a sqlite3 table and mainly consist of a notification type, brief message, and an extendable set of properties which are stored as a JSON object.

For the feed parser, I’m using gofeed, the same library I’m using for reading podcast feeds. I can definitely recommend this library for parsing RSS feeds if you’re using Golang. There was a little bit I had to add around this library to detect when feed items have previously been read or updated. The way I’m detecting this is by recording the GUID, along with a SHA-1 hash of the title, description, and content in the database. Parsing the feed HTML is done using goquery, allowing me to easily select the first img tag of a HTML fragment. For fetching and setting the categories, I’m using a home grown Micropub client.

So that’s “category fixer”. A lot of infrastructure was added for this one which could be useful in the future. I do have some other ideas that would follow this sort of pattern: a new post is picked up by the RSS reader, and an in-app notification is raised for me to action. I suspect this may becoming a bit of a pattern.

Brief Look At Microsoft's New CLI Text Editor

Mon, 23 Jun 2025 09:09:38 +1100

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! ↩︎

Fri, 16 May 2025 14:47:47 +1100

My first automation to assist me with this “issue driven development” approach: a Keyboard Maestro macro which will activate Obsidian, go to the end of the document, and add a new line beginning with the current time.

My goal is to have one Obsidian note per Jira task, which I will have open when I’m actively working on it. When I want to record something, like a decision or passing thought, I’ll press Cmd+Option+Ctrl+L to fire this macro, and start typing. Couldn’t resist adding some form of automation for this, but hey: at least it’s not some hacked-up, makeshift app this time.

Devlog: Blogging Tools — Ideas For Stills For A Podcast Clips Feature

Thu, 08 May 2025 00:18:48 +1100

I recently discovered that Pocketcasts for Android have changed their clip feature. It still exists, but instead of producing a video which you could share on the socials, it produces a link to play the clip from the Pocketcasts web player. Understandable to some degree: it always took a little bit of time to make these videos. But hardly a suitable solution for sharing clips of private podcasts: one could just listen to the entire episode from the site. Not to mention relying on a dependent service for as long as those links (or the original podcast) is around.

So… um, yeah, I’m wondering if I could building something for myself that could replicate this.

I’m thinking of another module for Blogging Tools. I was already using this tool to crop the clip videos that came from Pocketcasts so it was already in my workflow. It also has ffmpeg bundled in the deployable artefact, meaning that I could use to produce video. Nothing fancy: I’m thinking of a still showing the show title, episode title, and artwork, with the audio track playing. I pretty confident that ffmpeg can handle such tasks.

I decided to start with the fun part: making the stills. I started with using Draw2D to provide a very simple frame where I could place the artwork and render the text. I just started with primary colours so I could get the layout looking good:

I’m using Roboto Semi-bold for the title font, and Oswald Regular for the date. I do like the look of Oswald, the narrower style contrasts nicely with the neutral Roboto. Draw2D provides methods for measuring text sizes, which I’m using to power the text wrapping layout algorithm (it’s pretty dumb. It basically adds words to a line until it can’t fit the available space)

The layout I got nailed down yesterday evening. This evening I focused on colour.

I want the frame to be interesting and close to the prominent colours that come from the artwork. I found this library which returns the dominant colours of an image using K-means clustering. I’ll be honest: I haven’t looked at how this actually works. But I tried the library out with some random artwork from Lorem Picsum, and I was quite happy with the colours it was returning. After adding this library¹ to calculate the contract for the text colour, plus a slight shadow, and the stills started looking pretty good:

I then tried some real podcast artwork, starting with ATP. And that’s where things started going off the rails a little:

The library returns the colours in order of frequency, and I was using the first colour as the border and the second as the card background. But I’m guessing since the ATP logo has so few actual colour, the K-means algorithm was finding those of equal prominence and returning them in a random order. Since the first and second are of equal prominence, the results were a little garish and completely random.

To reduce the effects of this, I finished the evening by trying a variation where the card background was simply a shade of the border. That still produced random results, but at least the colour choices were a little more harmonious:

I’m not sure what I want to do here. I’ll need to explore the library a little, just to see whether it’s possible to reduce the amount of randomness. Might be that I go with the shaded approach and just keep it random: having some variety could make things interesting.

Of course, I’m still doing the easy and fun part. How the UI for making the clip will look is going to be a challenge. More on that in the future if I decide to keep working on this. And if not, at least I’ve got these nice looking stills.

The annoying thing about this library is that it doesn’t use Go’s standard Color type, nor does it describe the limits of each component. So for anyone using this library: the range for R, G, and B go from 0 to 255, and A goes from 0 to 1. ↩︎

Devlog: Godot Game Update

Sun, 27 Apr 2025 12:29:47 +1100

A brief status update on that Godot game. I think we’re pretty close to a finished 4-1 level. The underground section has been built, and the level has been decorated. I’ve also added a couple of secrets, which needed a few new mechanics — like doorways, which are used to transport the player around the level — plus some refinement to existing ones. I am a little concerned about the amount of waiting involved near the end of the first half, where the player will need to make their way across a large gap by jumping on the slow cycling “layer 2” tile layer. I’ll see what feedback I get from play-testers about this.

I’ve also filled in the backdrop of all the levels to date. The grey default background colour has been replaced with a sky made of colour bands that came with the asset set I’m using. It’s basic, maybe too basic, but as long as it doesn’t clash with the interactive elements, and in the interest of “merely shipping something,” I think it’ll do for now.

Finally, I made some changes from feedback I got from play-testers. Movement can now be made using WASD, along with the inverted-T arrow keys. I’ve also bound jump to the Enter key for those that want to use WASD. I made some changes in how secrets are telegraphed with the goal of making them more consistent. This is always a bit of a balancing act, as I don’t want to make them too obvious: they’re secrets after all. I added a tiny bit of “slip” to the player’s movement, so they don’t stop dead whenever the key is released. I didn’t want to go too far here: adding too much inertia introduced the risk of the player just falling off a platform after landing from a jump, which I don’t think is a great experience. And I fixed a window resizing bug (Godot enables window resizing by default, for anyone else who needs to know this).

I think the next thing to do is to organise another version for play-testers, just to gauge what they think of level 4-1. Then it’s either on to level 4-2, or even introduce a new level between 1-1 and 1-2 to reduce the ramp up in difficulty between the two levels. Fortunately I’ve got some ideas on what I want to do for both of theses, so they’ll be easy starters. I’ve still got nothing for level 2-1, but I have a few ideas on what I want to do for 2-2, so maybe I’ll start that too.

Fri, 11 Apr 2025 14:03:15 +1100

Does Vivaldi Mobile for Android have GIF support? Yes… I guess? Not entirely sure who’s asking. Or why. Are these the same people who want to know if Vivaldi has paid stickers or file sharing support? Is this for a hypothetical messaging app?

Tue, 08 Apr 2025 11:01:02 +1100

Blessed be the Mail.app View menu and the option to hide the useless Apple AI priority messages. My Inbox is now slightly more sane.

Sat, 29 Mar 2025 11:36:52 +1100

A bit more on the Godot game this morning, this time working on background tiles artwork. Made some grey masonry tiles for the end castle sequences. Also tried some background rocks for underground areas. I’m pretty rubbish at anything organic, but they didn’t turn out too bad.

Right side has the background tiles surrounded with their complementary foreground tiles on the left.

Sat, 29 Mar 2025 11:23:34 +1100

It pains me that Forgejo’s CI “pipeline running” animation spins anti-clockwise, as if you’re going backwards in time. A metaphor, perhaps? Services get undeployed, binaries go back to the source code, projects return to their seeds of ideas. 🤔💭

Oh, build’s done. Never-mind. 😀

Mon, 10 Mar 2025 21:29:31 +1100

Was looking at how I could add hazards to my Godot project, such as spikes. My first idea was to find a way to detect collisions with tiles in a TileMap in Godot. But there was no real obvious way to do so, suggesting to me that this was not the way I should be going about this. Many suggested simply using an Area2D node to detect when a play touches a hazard.

I was hesitant to copy and paste the scene node I had which handled the collision signal and kill the player — the so-called “kill zone” scene —but today I learnt that it’s possible to add multiple CollisionShape2D nodes to an Area2D node. This meant I needed only a single “kill zone” scene node, and just draw out the kill zones over the spikes as children. The TileMap simply provides the graphics.

This discovery may seem a little trivial, but I’d prefer to duplicate as few nodes as a can, just so I’ve got less to touch when I want to change something.

Mon, 10 Mar 2025 09:49:38 +1100

Tried opening my Godot project this morning and was greeted with the following error:

scene/resources/resource_format_text.cpp:284 - res://scenes/falling_platform.tscn:14 - Parse Error: 
Failed loading resource: res://scenes/falling_platform.tscn. Make sure resources have been imported by opening the project in the editor at least once.
Failed to instantiate scene state of "res://scenes/falling_platform.tscn", node count is 0. Make sure the PackedScene resource is valid.
Failed to load scene dependency: "res://scenes/falling_platform.tscn". Make sure the required scene is valid.

Traced it back to the technique I was using to respawn the falling platform. Looks like Godot didn’t like the two preloads I included:

# file: scripts/falling_platform.gd

@onready var FallingPlatform = preload("res://scenes/falling_platform.tscn")
@onready var FallingPlatformScript = preload("res://scripts/falling_platform.gd")

This resulted in a parse error and Godot thinking the level scene was corrupted. In retrospect, this kinda makes sense. What I doing was technically a circular dependency, where the scene and script was trying to preload itself. I was hoping Godot was smart enough to recognise this, but I guess not.

So I had to change the respawn code. I modified it to make use the duplicate method. Here’s the revised version:

func respawn():	
    var dup = self.duplicate()
    dup.global_position = init_global_position	

    # Duplicate also copies the velocity so zero it out here
    dup.velocity = Vector2(0, 0)
    get_tree().current_scene.add_child(dup)

After some limited testing, this seems to work. One good thing about this approach is that it looks like duplicate copies the script, so I no longer need to do anything special here.

So I guess the lesson here is don’t try to preload the script within itself.

Adventures In Godot: Respawning A Falling Platform

Sat, 08 Mar 2025 12:35:07 +1100

My taste of going through a Godot tutorial last week has got me wanting more, so I’ve set about building a game with it. Thanks to my limited art skills, I’m using the same asset pack that was used in the video, although I am planning to add a bit of my own here and there.

But it’s the new mechanics I enjoy working on, such as adding falling platforms. If you’ve played any platformer, you know what these look like: platforms that are suspended in air, until the player lands on them, at which point gravity takes a hold and they start falling, usually into a pit killing the player in the process:

The platforms are built as a CharacterBody2D with an Area2D that will detect when a player enters the collision shape. When they do, a script will run which will have the platform “slipping” for a second, before the gravity is turned on and the platform falls under it’s own weight. The whole thing is bundled as a reusable scene which I could drag into the level I’m working on.

I got the basics of this working reasonably quickly, yet today, I had a devil of a time going beyond that. The issue was that I wanted the platform to respawn after it fell off the map, so that the player wouldn’t get soft-locked at at an area where the platform was needed to escape. After a false-start trying to reposition the platform at it’s starting point after it fell, I figured it was just easier to respawn the platform when the old one was removed. To do this I had to solve two problems:

How do I get the platform starting point?
How can I actually respawn the platform?

Getting The Starting Point

A Node2D object has the property global_position, which returns the position of the object based on the world coordinates. However, it seems like this position is not correct when the _init function of the attached script is called. I suspect this is because this function is called before the platform is added to the scene tree, when the final world coordinates are known.

Fortunately, there exists the _ready notification, which is invoked when the node is added to the scene tree. After some experimentation, I managed to confirm that global_position properly was correct. So tracking the starting point is a simple as storing that value in a variable:

var init_global_position = null

func _ready():
	init_global_position = global_position

Another option is to use the _enter_tree() notification. From the documentation, it looks like either would probably work here, with the only difference being the order in which this notification is invoked on parents and children (_enter_tree is called by the parent first, whereas _ready is called by the children first).

Respawning The Platform

The next trick was finding out how to respawn the platform. The usual technique for doing so, based on the results of my web searching, is to load the platform scene, instantiate a new instance of it, and added it to the scene tree.

@onready var FallingPlatform = preload("res://scenes/falling_platform.tscn")

func respawn():	
    var dup = FallingPlatform.instantiate()
    add_child(dup)

Many of the examples I’ve seen online added the new scene node as a child of the current node. This wouldn’t work for me as I wanted to free the current node at the same time, and doing so would free the newly instantiated child. The fix for this was easy enough: I just added the new node as a child of the current scene.

@onready var FallingPlatform = preload("res://scenes/falling_platform.tscn")


func respawn():	
    var dup = FallingPlatform.instantiate()
    get_tree().current_scene.add_child(dup)
    queue_free()

I still had to reposition the new node to the spawn point. Fortunately the global_position property is also settable, so it was simply a matter of setting that property before adding it to the tree (this is so that it’s correct when the newly instantiated node receives the _ready notification).

@onready var FallingPlatform = preload("res://scenes/falling_platform.tscn")

func respawn():	
    var dup = FallingPlatform.instantiate()
    dup.global_position = init_global_position
    get_tree().current_scene.add_child(dup)
    queue_free()

This spawned the platform at the desired positioned, but there was a huge problem: when the player jumped on the newly spawn platform, it wouldn’t fall. The Area2D connection was not invoking the script to turn on the gravity:

It took me a while to figured out what was going on, but I came to the conclusion that the packed scene was loading properly, but without the script attached. Turns out a Script is a resource separate from the scene, and can be loaded and attached to an object via the set_script method:

@onready var FallingPlatform = preload("res://scenes/falling_platform.tscn")
@onready var FallingPlatformScript = preload("res://scripts/falling_platform.gd")

func respawn():	
    var dup = FallingPlatform.instantiate()
    dup.set_script(FallingPlatformScript)

    dup.global_position = init_global_position
    get_tree().current_scene.add_child(dup)
    queue_free()

Finally, after figuring all this out, I was able to spawn a new falling platform, have it positioned at the starting position of the old platform, and react to the player standing on it.

The time it took to work this out is actually a little surprising. I was expecting others to run into the same problem I was facing, where they were trying to instantiate a scene only to have the scripts not do anything. Yet it took me 45 minutes of web searching through Stack Overflow and forum posts that didn’t solve my problem. It was only after a bit of experimentation and print-debugging on my own that I realised that I actually had to attached the script after instantiating the node.

To be fair, I will attribute some of this to not understanding the problem at first: I actually thought the Area2D wasn’t actually being instantiated at all. Yet not one of the Stack Overflow answers or forum post floated the possibility that the script wasn’t being loaded alongside the scene. This does suggest to me that my approach may not be optimal. There does exist a “Local to Scene” switch in the script inspector that could help, although turning it on doesn’t seem to do much. But surely there must be some way to instantiate the script alongside the scene.

Anyway, that’s for later. For now, I’m happy that I’ve got something that works.

Thu, 06 Mar 2025 15:49:37 +1100

🔗 cathoderay.tube

Yes.

Running PeerTube In Coolify

Sat, 01 Mar 2025 15:39:21 +1100

A few months ago, I moved my PeerTube instance over to Coolify, so that I could shutdown the Linux instance it was running on. I had a PeerTube instance for a little over a year, although I hardly posted anything on there and it’s never seen much traffic. I did want to keep it around though, as I had a few video embeds scattered around the internet. It just didn’t need to be on it’s own server.

This post is not about how I ported this instance over to Coolify. It’s been a few months, and several hours of trial and error to get that working. But I had been asked how one could setup their own PeerTube instance in Coolify, and I wanted a documented approach for how one could do so, should there be a need to spin up a new instance from scratch. PeerTube is not one of the builtin services that Coolify offers, at least at the time of this post, so a manual process to setting this up is required.

A few notes about the PeerTube instance you will have at the end of this process:

The database and videos will be stored on the host’s file system. This should keep them persistent over container redeployments but will mean you’ll need to make sure the host’s file system is backed up somehow. Most VPS’s have a backup option, and PeerTube does offer a way to upload videos to an object store, although I’m not sure how to set that up.
Email sending will be disabled. This works for me as I’m hosting these videos for myself, and I didn’t want to go through the trouble of deploying Postfix or paying for a hosted SMTP.

Note also that this is not the approach I took to setup my instance, so some things may not be correct or may require further efforts to get working properly. Consider this as more of a “getting starting” guide, rather a comprehensive go-to-production process.

Prerequisite

You will need:

Coolify.
A suitable Linux host managed by Coolify that meets PeerTube’s minimum specs. It can be the same host that’s running Coolify if necessary, but a separate one is probably worth considering, just so that it doesn’t interfere with Coolify itself.
A domain name to use, for example “peertube-demo.lmika.xyz”.

I’d recommend using Caddy as a Coolify proxy so as to get automatic TLS certificates.

Docker Compose

We’ll be using a modified version of PeerTube’s Docker Compose file, with the .env file embedded and the Nginx deployments removed. A copy of the file is provided below:

x-env: &env
  environment:
    # Database / Postgres service configuration
    POSTGRES_USER: peertube
    POSTGRES_PASSWORD: <database-password>
    POSTGRES_DB: peertube
    PEERTUBE_DB_USERNAME: peertube
    PEERTUBE_DB_PASSWORD: <database-password>
    PEERTUBE_DB_SSL: false
    PEERTUBE_DB_HOSTNAME: postgres
    
    # PeerTube server configuration
    PEERTUBE_WEBSERVER_HOSTNAME: <peertube-domain>
    PEERTUBE_WEBSERVER_HTTPS: true
    PEERTUBE_WEBSERVER_PORT: 443
    # If you need more than one IP as trust_proxy
    # pass them as a comma separated array:
    PEERTUBE_TRUST_PROXY: '["127.0.0.1", "loopback", "172.18.0.0/16"]'
    
    PEERTUBE_OBJECT_STORAGE_UPLOAD_ACL_PUBLIC: "public-read"
    PEERTUBE_OBJECT_STORAGE_UPLOAD_ACL_PRIVATE: "private"
    
    # Generate one using `openssl rand -hex 32`
    PEERTUBE_SECRET: <random-string>
    
    #PEERTUBE_LOG_LEVEL=info
    
    # /!\ Prefer to use the PeerTube admin interface to set the following configurations /!\
    #PEERTUBE_SIGNUP_ENABLED=true
    #PEERTUBE_TRANSCODING_ENABLED=true
    #PEERTUBE_CONTACT_FORM_ENABLED=true
    
    # E-mail configuration
    # If you use a Custom SMTP server
    #PEERTUBE_SMTP_USERNAME:
    #PEERTUBE_SMTP_PASSWORD:
    # Default to Postfix service name "postfix" in docker-compose.yml
    # May be the hostname of your Custom SMTP server
    PEERTUBE_SMTP_HOSTNAME: postfix
    PEERTUBE_SMTP_PORT: 25
    PEERTUBE_SMTP_FROM: noreply@<peertube-domain>
    PEERTUBE_SMTP_TLS: false
    PEERTUBE_SMTP_DISABLE_STARTTLS: false
    PEERTUBE_ADMIN_EMAIL: <peertube-admin-address>

services:
  peertube:
    image: chocobozzz/peertube:production-bookworm
    <<: *env
    ports:
     - "1935:1935"
     - "9000"
    volumes:
      - ./docker-volume/data:/data
    depends_on:
      - postgres
      - redis
      # - postfix
    restart: "always"

  postgres:
    image: postgres:13-alpine
    <<: *env
    volumes:
      - ./docker-volume/db:/var/lib/postgresql/data
    restart: "always"

  redis:
    image: redis:6-alpine
    volumes:
      - ./docker-volume/redis:/data
    restart: "always"

  # Uncomment if you want to use postfix (I don't so I left it disabled)
  # postfix:
  #   image: mwader/postfix-relay
  #   <<: *env
  #   volumes:
  #     - ./docker-volume/opendkim/keys:/etc/opendkim/keys
  #   restart: "always"

Make a copy of this file in a text editor and replace the following placeholders:

<database-password>: Choose a suitable, preferably random, password to use for the database.
<peertube-domain>: Your domain of choice, e.g. peertube-demo.lmika.xyz. This should be without the “https://”
<random-string>: Generate a random string by running openssl rand -hex 32 and use that here
<peertube-admin-address>: This is unused but should be set to avoid server errors. Set it to something suitable, such as admin@peertube.example.com.

Deploying The Service

Log into Coolify, go to “Projects”, and click “Add”. Give your project a name then click “Continue”.

Within the project, add a new resource. The resource you’d want to choose is “Docker Compose Empty”.

Select the server you want to deploy PeerTube to, then copy and paste the compose file (make sure the placeholders are set).

Before deploying, we’ll need to setup the proxy. In the Services list, locate the “PeerTube” one and click “Settings”.

In the “Domains” text field, enter https://<peertube-domain>:9000 (the port number is used by Coolify to map the service to the proxy, but the service will be listening on port 443).

Click “Save”, then click “Back” to go back to the list of services, then click “Deploy”. Wait for the containers to be provisioned, then try visiting https://<peertube-domain>/ to see if it deployed successfully.

The last thing you’ll need to do is get the generated password for the root user. You can do that by clicking the “Logs” tab, getting the recent log messages from the “PeerTube” container, and doing a find-in-page search for “User password”.

Alternatively, you can set the password yourself by going to the Terminal, connecting to the PeerTube container, and typing in the following:

npm run reset-password -- -u root

You then should be able to login into the frontend as “root” and continue setting up your instance from there.

At this point, you should have a functioning PeerTube instance. The rest of the setup you can do from the web interface.

You’ll need to perform additional steps to get email working; and you’ll need to make additional changes if you want to host your videos in an object store, and potentially use some of the advanced features like uploading via Torrent or publishing a live. I’ve not done any of these myself, but information on how to do this should be findable within PeerTube’s documentation page. The Docker Compose file should be editable from within Coolify; the trick is finding out which environment variables you’ll need to set (and just beware that Docker compose “normalises” the YAML file so you may need to adjust environment variables in both the x-env and the service environments section). But hopefully this should be enough if all you want to do is host videos on your own infrastructure.

Tue, 25 Feb 2025 21:23:02 +1100

Gave Dave Winer’s Wordland a try today. I like it. It’s quite a nice writing environment to work in. Wrote a couple of long form posts in it, along with a few that were a paragraph or two, and the editor felt great to use. Does a good job growing with the length of the piece too.

Making A Small Two-Letter Country Code Lookup Page

Thu, 20 Feb 2025 08:57:14 +1100

Made a small thing yesterday.

I’ve been seeing links to the uchū color pallette and Atkinson Hyperlegible font on Mastodon this past week and I wanted to give them a try on something. With little else to work on, I thought I’d spend yesterday evening building a small thing I’ve been wishing I had at work for a while.

My tasks at work has me looking up the two-letter country codes a lot recently. My goto is the ISO-3166-1 alpha 2 page on Wikipedia, but getting there involves a few clicks, a web-search, and a “find on page.” I wanted an easier way to get to this list, and a much easier way to filter it. I also wanted something that could work as a Vivaldi side panel, so that I can call it up while I’m looking at something else.

What I ended up building is this, which I’ve called 2LCC, which stands for Two Letter Country Codes.

Start entering a country name or country code to filter the table.

Because two-letter codes will appear as letters within country names, any exact match in either the code or the country name will highlight the row in yellow.

How it looks in Vivaldi's sidebar.

It was built using Hugo, which some might think may be a bit overkill, but Hugo does has some nice utilites for reading JSON data and running it through a Go template to produce static HTML. And that’s all this is: a static HTML page with a big table of country codes with a smattering of CSS and JavaScript. The JavaScript is just vanilla, and is simply used to power the filter, which basically walks the table, hiding rows which don’t contain the filter string. I was originally going to have the filter logic test the inner text elements of the table cells, but I decided to have the template spit out the country code as data- attributes instead. It’s easier to fetch in JavaScript using the dataset property list and since the values are spat out by the template in lowercase, it makes case insensitive slightly easier.

We’ll see how often I end up using this: there’ve been instances when I’ve over-index needing something for my job, only to build it and find myself using it less than I imagined. It probably wasn’t a great project to choose for trying out uchū colour scheme, seeing that I only ended up using two colours. But I’m happy with how the two colours I used turned out, and the the font looks great. And I do like that I took on more of the layout styling myself, rather than simply defer to simple.css.

Here’s a link to it should this be useful to you: https://2lcc.lmika.app/.

Sat, 15 Feb 2025 11:10:08 +1100

Dusted off Podcast Favourites (last commit 25 April 2022) and fixed a longstanding issue of thumbnails being lost when they’re changed in the feed. Editing the feed properties will now force a refresh of the thumbnail URLs. Didn’t need to change anything else, which was a nice change.

Thu, 13 Feb 2025 07:48:59 +1100

🔗 Prefer Numbered Lists to Bullets

Good arguments for using numbered listed instead of bullets in chat communication. I don’t disagree with any of them. I will say that tend to preferred bulleted lists simply because the chat apps I use tend to make using numbered lists more difficult than it should be. Slack, for example, only starts a “real” numbered list when it detects you type 1.. And once you’ve started, there’s no way to skip ordinals within the same numbered list.

Note that "1. This" the only "real" numbered list, and has a different appearance.

Even Obsidian’s implementation is not perfect. Despite making it easy to start a numbered list at an arbitrary ordinal, it’s still not possible to skip ordinals.

It’d be simpler if they didn’t try to automatically make “real” numbered lists at all.

Via: Jim Nielsen

Tue, 04 Feb 2025 07:55:29 +1100

Trying out Bayou theme by @Mtt on a test blog. Lots to like about it, especially the idea of having the latest micro-post appear in the form of a status message. Very unique.

Mon, 03 Feb 2025 07:58:01 +1100

Already making daily note archives for 2025.

Wed, 29 Jan 2025 16:38:36 +1100

Okay, I think I know why I stopped playing Wordle.

Sun, 26 Jan 2025 10:41:50 +1100

Finding that styling a page with min-height: 100vh causes the need to scroll when I open the page in Vivaldi Mobile, as vh does not recognise vertical space taken up by toolbars. What I actually want is 100dvh (i.e. dynamic view-height) which does. Found this slide helpful (source and via).

Sat, 25 Jan 2025 16:03:08 +1100

This week’s distraction: building a Wordle clone. No particular reason for doing this other than I felt like building one, although I did miss the small time waster of the original Wordle, and watching a game show with my parents that had a similar concept just made those feelings stronger. Main difference between this and Wordle classic: board randomly selects between 4-letter, 5-letter, and 6-letter words; no daily limit or social-media sharing when you guessed the word correctly; and the biggest one: UK English spelling.

Some remarks on how this was built: I used 11ty to build the static site. It originally started as just a HTML page with some JavaScript, but I wanted to leave the option open for bundling and minifying the JS with Stimulus. The dictionary I got from Hunspell, which is apparently the spell checker Apple has based their work on. There is a little bit of Go to filter and sort the dictionary of words. The words are in sorted order for the binary search algorithm to check if a word exists or not. The puzzle order is predetermined and was done by “shuffling” the indices in a separate array. Base styles are, of course, from simple.css.

If you’re interested in checking it out, you can find it here. Just be aware that it may not be as polished as much of the other stuff you find out there. Turns out that I can tolerate a fair few shortcomings in things that I build for my own amusement.

Wed, 08 Jan 2025 11:07:43 +1100

Keyboard Maestro is coming into its own as a way for scheduling recurring tasks. I’ve just set one up for a daily report I need to run. It’s little more than a shell script so I probably could’ve used crontab to do it, but is so much easier configuring and testing it in Keyboard Maestro.

Sun, 05 Jan 2025 17:10:47 +1100

I recently got a new phone, a Pixel 9 Pro, which meant I needed to bring Alto Player up to date. I probably could’ve gotten away using the version I was using on my Pixel 6. But I didn’t have a binary build, and I needed to upgrade Gradle anyway, so I decided to spend a bit of time bringing it up to date to API version 35, the version used in Android 15.0. Fortunately it was only a few hours in total, and once I got it running in the simulator, I side-loaded it onto my phone and started using it.

It worked, but there were some significant UI issues. The title-bar bled into the status bar, the album image in the Now Playing widget was cropped by the curved corners of the phone, and the media notification didn’t display playback controls.

Evolution of the window insets, from left-to-right: before any changes, version with the album cover and margin, final version with no album art.

I set about fixing these issues today, starting with the title-bar and Now Playing widget. These was an issue with the views not respecting the window insets, and after a quick Google search, I found this article showing how one could resolve this by adding a ViewCompat.setOnApplyWindowInsetsListener and reacting to it by adjusting the margins of the view.

val topLevelLayout = findViewById(R.id.top_level_layout) as CoordinatorLayout
ViewCompat.setOnApplyWindowInsetsListener(topLevelLayout) { v, windowInsets ->
    val insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
    v.updateLayoutParams<ViewGroup.MarginLayoutParams> {
        leftMargin = insets.left
        bottomMargin = insets.bottom
        rightMargin = insets.right

        // applying a top margin here would work, but will not have the toolbar
        // background colour "bleed" into the status bar, which is what I want.
    }

    val t = v.findViewById<Toolbar>(R.id.toolbar)
    t.updateLayoutParams<ViewGroup.MarginLayoutParams> {
        // make the toolbar a little "narrower" than full height
        topMargin = insets.top * 3 / 4
    }

    WindowInsetsCompat.CONSUMED
}

It took a few attempts, but I managed to get this working. Just using the top inset for the toolbar margin made it a little larger than I liked, so I adjusted the height to be 75% of the inset. This means the toolbar will actually encroach into the area reserved for cut-outs like the front-facing camera. This is arguably not something a “real” Android apps should do, but this is just for me and my phone so it’s fine.

I went through a few iterations of the album artwork cutoff on the bottom right corner trying to find something I liked. I tried bringing in the horizontal margins a little, but I didn’t like the alignment of the album art in the player, particularly compared to the covers that appear in the track list screen. One thing I didn’t try was raising the bottom margin so that it would fit “above” the curve. But those corners curve in quite a bit, and doing this would sacrifice a lot of vertical space. So I settled on hiding the album art altogether. It’s a bit of a shame to loose it, but at least it looks neater now.

The next thing I looked at was fixing the playback controls in the media notification. After some investigating, I found that this was because I was not setting the available actions in the PlaybackStateCompat builder. This, if I understand correctly, is used to communicate to various systems the current state of the playing media: what the track name is, whether it’s playing, whether one can skip forward or back. I have my own types for tracking this information — which is probably not correct but I wasn’t completely sure as to what I was doing at the time with Android’s media stack¹ — and when I needed to convert this to a type understood by the framework, I made instances of this builder without setting the available actions. Earlier versions of Android seemed not to care, and the controls always appeared on the notification. But I guess they changed that.

Evolution of the playback notification, from left-to-right: before any changes, the request to show notifications upon first launch (this is defined by the system), the playback notifications with controls again.

One other thing I needed to do was to explicitly ask the user permission to show a notification before I could publish one. This is also relatively new: my experience with Android goes back to the early days where these permissions were disclosed up front when the app was installed. But I can completely understand why they changed it, as it was easy to simply tap through those screens with reading them. I am wondering whether media playback notifications are in some way exempt from these permission checks, as I was actually getting one to appear before I made this changes. But I figured it was probably worth doing anyway, so I added this permission request on first launch. Arguably I should be asking for this permission when playback starts, but again, this is just for me.

One final thing I needed to address were long album titles. The text view displaying the the album title had a width that autosized to the title itself, and the start and end constraints were set such that it appears centred in the view. This worked for “normal” length titles but when the length became excessive, the text view would fill the entire width of the screen and the title will appear left justified.

Before (left) and after (right) shot of the fixed album title.

The fix for this was to set the text width to be calculated by the start and end constraints (setting layout_width to 0dp), bringing in the margins a little, and making the label text centre justified. I did this already for the track title, so it was easy to do this here too. Not sure why I didn’t do it earlier, or why I haven’t done it for the artist’s name yet.

This was all rushed, and I’ll admit I wasn’t 100% sure what I was doing. I was going down the route of trial-and-error to get this working, mixed in with web searches and a trip to ChatGPT. And yeah, the methods I used won’t make this a portable Android app that would work on every phone out there. But I’m reasonably happy with how it turned out.

This is still true to this day. ↩︎

Sat, 04 Jan 2025 15:25:43 +1100

Thanks for my new found fondness of buying mainstream music instead of streaming it, I needed a way to get these albums into Alto Catalogue. There exists a feature for fetching and importing tracks from a Zip referenced by a URL. This works great for albums bought in Bandcamp, but less so for any tracks I may have on my local machine.

I’ve managed to get Alto Catalogue building again after updating Webpack and a few NPM packages, so in theory, I could add an Upload Zip file action. But there’s more to this than simply accepting and unpacking a Zip file. I have to read the metadata, maybe even preview the tracks that will be imported, just in case I’m importing something I rather not (I did see this once, where zipping a bunch of tracks in the Finder introduced duplicates). This already exists for Zip files that are downloadable online.

I had a though about what my options are, until I remembered that I had a Gokapi instance running in Pikapods. So I tried using that to temporarily host the Zip file with a publicly available URL that could be read by Alto Catalouge.

The only problem is my internet upload speed is sooooo sloooooow. The Gokapi instance is hosted in Europe, and I suspect the instance itself is a little underpowered. So uploading 100 MB Zip files would take a fair bit of time: maybe 15-30 minutes. When I tried doing this via the web frontend, the connection timed out.

Fortunately, Gokapi has an API and one of the methods allows you to upload a file in “chunks,” which Gokapi will assemble back into the original file. Even better is that this chunking can be uploaded in parallel.

So I built a CLI tool which made of this chunking API to upload the Zip files. Once the upload is complete, the tool will display the hot-link URL, which I can copy-and-paste into Alto Catalogue.

The whole process isn’t fast (again, slow upload speeds). But it works, and I can use this tool to queue a bunch of uploads and let it do its thing while I’m doing something else. I really like tools that do this, where you’re not forced to babysitting them through the process.

There are a few limitations with it. It doesn’t allow for an awful lot of customisations on the lifecycle of the uploaded file. And the tool stalled out once when my computer went to sleep, and I had to start the upload from scratch. I could probably add something to track the chunks that were successful, allowing one to continue a stalled upload. If this happens frequently, I may look more into adding this.

But even so, this could be a useful addition to my use of Gokapi for transferring temporary files. If you think this might be useful to you, you can find the tool here.

Home Screen Of 2024

Sun, 29 Dec 2024 21:51:21 +1100

It’s just turned 3:00 in the afternoon, and I was alternating between the couch and the computer desk, racking my brain on what to do. With no ongoing projects — a few ideas have been bouncing around, yet none has grabbed me so far, and I had nothing else in a state where I could just slip on some music or a podcast and work on — and seeing a few others make similar posts on their blogs, I’d figured I talk about my home screens.

I realised that I haven’t actually done this before, mainly because my home screens change very slowly (the background hardly ever). Dramatic changes usually come about when I’m setting up a new phone.

And yet, I do want to talk a little about the apps I have at the moment, and I did want to make sure I had a record of how the home screens looked. And seeing that I needed to keep myself occupied doing something, now is as good a time as any.

Screen One

This screen contains two widgets — the date and weather widget at the top, and the calendar widget on the right — plus a small collection of apps placed deliberately where they are. The apps I have here are not necessarily the most used (although two of them are) but I like having easy access to them for various reasons.

Aside from the widgets, the apps I have on this screen — from left to right, top to bottom — are as follows:

Micropub Checkin: A silly little Flutter app I used for adding check-ins to lmika.day. The apps in a bit of a neglected state, but I still use it as I get value from tracking places I’ve been.
Strata: The note’s app from Micro.blog. This is where I write my short-term notes. I use Google Keep for shopping lists, but everything else goes here.
Alto: A music app I wrote, and the main music app I listen to.
Pocket Casts: The podcast player app I use. Apart from the web-browser, this and Alto are two of the most used apps I have on my phone.
VSReader: Another silly little Flutter app. This is a test build for an RSS reader I was working on a couple of months ago. It’s been a while since I’ve opened this, and I probably should just kill it given that I haven’t made any recent changes to it.
Google Wallet: Google’s digital wallet (well, at least their current iteration of their digital wallet). I use it mainly for my train ticket but I do have my credit card in there, just in case I walk out without my “real” wallet.

The items in the dock are as follows:

Phone: My family and I still use the phone quite frequently so this app has remained in the dock since I set the phone up.
Messages: This is Android’s messaging app. Much like the phone, I communicate with family mostly via SMS, and now RCS, messages.
Play Store: I rarely go to the Play Store, so there’s no real need for this icon to be here. But I haven’t got around to removing it yet.
Vivaldi: My web browser of choice.
The right most icon changes based on the last used app, which I’m not a huge fan of, as it occasionally changes just as I go to tap it and I launch the wrong app by mistake.

Screen Two

A grab-bag of apps I frequently use. Some of them probably should be on the first screen, but since real-estate is at a bit of a premium I just keep them here, and swipe over when I need them.

From left to right, top to bottom, the apps on this screen is as follows:

PTV: The Victorian public transport app. I usually use it to know the arrival time of the tram I take going home. Also useful for trip planning.
Plex: I generally don’t watch things on my phone, but before I got my Nvidia Shield, I used this Plex app to Chromecast shows to the TV. It was never great at it though, as it sometimes disconnected from the Chromecast session while the video was running, leaving me with no means of stopping it until I unplugged the Chromecast.
Kindle: Kept here as I occasionally use it to read books if I’ve read through my RSS feeds.
ChatGPT: I don’t use ChatGPT on my phone that often, but it does occasionally come in useful when a web-search proves fruitless.
FastMail: My email provider of choice. Given how often I use it, this is arguably one of those apps that should be on the first screen.
Pager Duty: The twenty-four hours on-call paging software I had to use for work. I’m no longer on the on-call roster so it’s probably something I can remove.
WhatsApp: What I use for messaging friends. I don’t like the fact that I have a Meta app on my phone, but that’s what my friends chose to use so I’m stuck with it (it’s also better than Viber, which is what we used before).
WireGuard: Personal VPN, although I’m currently not using WireGuard for anything right now. I like to keep it mainly because I like the logo.
Discord: I’m a member of a few Discord servers, but I use the mobile client mainly to check into the Hemispheric Views Discord.
Notion: Where I store my “long term” notes, at least for now.
Tusky: Mastodon client.
Splitwise: Group expense management and splitting app. This was useful during our European trip last year, where each of us would take in turn to pay for the group.
SunSmart: Used to track the current and forecasted UV index. Useful around this time of year if I’m planning to be outside for an extended period of time.
Micro.blog: The Micro.blog app, although I occasionally use the web version too.
1Password: My password manager of choice.
Realestate.com: Used to browse real-estate, out of curiosity more than anything else.
Spotify: My “secondary” music app. I don’t use it for anything that I regularly listen to, but it’s occasionally useful for those once-off tracks.
Google Authenticator: Where I keep my 2FA codes.
Day One: Before I moved to a web-based journalling app, I used this Day One client for writing journal entries. It wasn’t perfect: there was always syncing delays to/from the Apple platform instances of Day One. But it was fine.
Slack: Used mainly for work.
Camera: I’m not sure why I have this here, since I almost always use the double power-button tap to bring up the camera. I guess I moved it here from screen one and never removed it.

Screen Three

This is a screen I hardly ever used, as it’s mainly reserved for apps that are useful while travelling. The Booking.com app and Emirates apps I can probably remove: I was using them mainly to track flights and accomodation during my European trip last year.

The only one worth keeping is Airalo, which allows you to buy and setup data SIMs that work overseas. This has been really useful to me during my last couple of trips, and I hope to keep using it for trips in the future. It doesn’t offer a lot of data, but any data is better than zero data, as my friends — who continued asking to use my data when we’re out of WiFi range — can attest.

Thu, 26 Dec 2024 21:09:14 +1100

Released version 1.2.0 of Sidebar for Tiny Theme. In this version, the sidebar can now be configured to appear on pages other than just the home page. Options include showing it on the pages of posts, or pages other than posts. With both on, the sidebar will now appear on all pages of the site.

Mon, 23 Dec 2024 10:10:19 +1100

Thought I’d have another go at looking at BoxedWine for making an online archive of my old Delphi projects. They’ve been some significant improvements since the last time I looked at it. They don’t run fast, but that’s fine. As long as they run.

That Which Didn't Make The Cut

Sat, 21 Dec 2024 09:38:09 +1100

I did a bit of a clean-up of my projects folder yesterday, clearing out all the ideas that never made it off the ground. I’d figured it’d be good to write a few words about each one before erasing them from my hard drive for good.

I suppose the healthiest thing to do would be to just let them go. But what can I say? Should a time come in the future where I wish to revisit them, it’d be better to have something written down than not. It wouldn’t be the first time I wished this was so.

Anyway, here are the ones that were removed today. I don’t have dates of when these were made or abandoned, but it’s likely somewhere between 2022 and 2024.

Interlaced

This was an idea for a YouTube client¹ that would’ve used YouTube’s RSS feeds to track subscriptions. The idea came about during a time when I got frustrated with YouTube’s ads. I think it was an election year and I was seeing some distasteful political ads that really turned me off. This would’ve been a mobile app, most likely built using Flutter, and possibly with a server component to get this working with Chromecast, although I had no idea how that would work.

This never got beyond the UI mock-up stage, mainly because the prospect of working on something this large seemed daunting. Probably just as well, as YouTube solved the ads problem for me, with the release of YouTube Premium.

Red Crest

I thought I could build my own blogging engine and this is probably the closest I got (well, in recent years). This project began as an alternative frontend for Dave Winer’s Drummer, rendering posts that would be saved in OPML. But it eventually grew into something of it’s own with the introduction of authoring features.

I got pretty far on that front, allowing draft posts and possibly even scheduled posts (or at least the mechanics for scheduled posts). One feature I did like was the ability to make private posts. These would be interleaved with the public ones once I logged in, giving me something of a hybrid between a blogging CMS and a private journal. It was also possible to get these posts via a private RSS feed. I haven’t really seen a CMS do something quite like this. I know of some that allow posts to be visible to certain cohorts of readers, but nothing for just the blog author.

In the end, it all got a bit much. I started preparing the screen for uploading and managing media, I decided it wasn’t worth the effort. After all, there were so many other blogging CMS’s already out there that did 90% of what I wanted.

The public post list, styled using simple.css, naturally. I'm not sure how I came up with the name 'Random Posts of Consciousness.' Might've just been a working title.

Click the hash to go to a single post. Simple enough.

But once you logged in, you get to see all the private posts, plus an option to add a new post straight from the home page.

Options to edit and delete posts also appear on a single post page.

The post editor. This was a simple text that accepted Markdown. Titles are optional, as they should be.

Click 'Details' to edit the publish date (either a past date or the future date to schedule it) and choose whether the post is private or not.

The General admin section, showing Draft posts and proving access to the private RSS feed. I think the drafts table was a mock-up; I can't remember draft posts being a thing at the time.

The Post admin section, showing any draft and scheduled posts. The scheduled post table was definitely a mock-up.

The Media admin section, and the ultimate realisation that I didn't want to work on this anymore.

Reno

As in “Renovation”. Not much to say about this one, other than it being an attempt to make a Pipe Dreams clone. I think I was exploring a Go-based game library and I wanted to build something relatively simple. This didn’t really go any further that what you see here.

Tileset free for anyone who wants it.

SLog

Short for “Structured Log”. This was a tool for reading JSON log messages, like the ones produce by zerolog. It’s always difficult to read these in a regular text editor, and to be able to list them in a table made sense to me. This one was built for the terminal but I did make a few other attempts building something for this; one using a web-based GUI tool, and another as a native MacOS app. None of these went very far — turns out there’s a lot of tedious code involved — but this version was probably the furthest along before I stopped work.

Despite appearing on this list, I think I’ll keep this one around. The coding might be tedious, but I still have need something like this, and spending the time to build this properly might be worth it one day.

Miscellany

Here are all the others that didn’t even get to the point that warranted a screenshot or a paragraph of text:

s3-browse: a TUI tool for browsing S3 buckets. This didn’t go beyond simply listing the files of a directory.
scorepeer: An attempt to make a collection of online score-cards much like the Finska one I built.
withenv: Preconfigure the environment for a command with the values of an .env file (there must be something out there that does this already).
About 3 aborted attempts to make a wiki-style site using Hugo (one called “Techknow Space” which I though was pretty cleaver).

I’m sure there’ll be more projects down the line that would receive the same treatment as these, so expect similar posts in the future.

Or possibly a Peertube client. ↩︎

Thu, 19 Dec 2024 20:31:34 +1100

I’m not a fan of the changes Google made to their Weather app. It assumes you’re interested in saving every location you search for as a favourite, which is not how I use search. And horizontal scrolling for the 10 day forecast? With no date?

No, sorry. This is a step backwards in design.

Tue, 17 Dec 2024 22:00:25 +1100

Exploring Godot to see if I could use it to make a card game. I got this far:

Yep, I’m on a roll. 😄

Might need to work through a couple Godot tutorials first, just so that I understand the basics.

Thu, 12 Dec 2024 08:48:00 +1100

I plan to integrate UCL into another tool at work, so I spent last night improving it’s use as a REPL. Added support for onboard help and setting up custom type printing, which is useful for displaying tables of data. I started working on the tool today and it’s already feeling great.

Wed, 11 Dec 2024 08:10:41 +1100

If there’s one thing I’d like to see added to Go for 2025, it’s type parameter support on methods. It’s still not possible to do something like this:

Which is a real shame, as I’ve got some ideas on how I could use these. Building something like Java streams, for example.

Sat, 07 Dec 2024 11:05:54 +1100

Some more work on that feed reader app. You know how I said that I wanted to hold off looking at appearances? Well, I abandoned that approach when I installed the app on my phone and tried viewing a few articles. And oof! There’s work to be done there.

First, it’s slow. Very slow. It’s taking a good second or two to pull feeds and entries from Feedbin. I was expecting this, and I’ve got a few plans on how to speed this up. But the biggest concern is the janky list scrolling. I mean, I wasn’t expecting the buttery smoothness of iPhone list scrolling, but I expected Flutter to be better than what I was experiencing. I’m hoping that it’s just because I was running a debug build, but part of me fears that Flutter is just not optimised for smooth list scrolling, favouring ease of development and a common runtime. I rather not change frameworks now, especially after spending an evening dealing with all the build issues, but I don’t want to live with this for ever.

But speed is not the biggest issue. The biggest offender was the feed reader view. The embedded web-view was only lightly styled, and it felt like it. The margins were all off, and I didn’t like the default font or colours. It made reading the article a bad experience to a surprising degree. I’ve dealt with rushed or poorly designed UIs in the past, but I didn’t have much tolerance for this. Not sure why this is, but I suspect it’s because I’ve been using feed readers that put some effort into the design of their reader screen.

In any case, a couple of evenings ago, I decided to put some effort into the styling. I replace the body text font with Noto Sans and the fixed-font with Ubuntu Mono. I dropped the font-size a little to 1.05 em (it was previously 1.1 em, with felt a little big, and 1.0 em felt a little small). I bought the margins in a little. And I styled the block-quote, figure, and pre elements to an appearance that, despite being a little overused, felt quite modern.

The results look much better, at least to my eye (and my emulator). Here are some side-to-side comparison shots of the changes (left side is the unstyled version, while the right side has the new styling changes):

Demonstration of the new font and link colouring choices.

Demonstration of the changes to block-quotes. Having a line down the left-sided is a pretty common style, but it's one I like.

Demonstration of code blocks and figures with captions.

I still need to actually install this on my phone and try it out. I’m wondering whether I should do so after a bit more work syncing the read status with Feedbin. That’s a feature that’s keeping me on Feedbin’s PWA for now.

Tue, 03 Dec 2024 22:45:18 +1100

Spent the last few evenings continuing work on a Flutter-based RSS feed reader. This project is now further along then my previous attempts at doing this. I’m at the point where feeds and feeds items are being fetch from Feedbin and displayed in a list view:

The beginning of the feed list

The feed item list. Title-less posts are to be fully supported, with a bulk of the summary shown in the list. Titled posts should have a smaller summary.

The aesthetics are taking a bit of a back seat in favour of functionality for now; I haven’t even changed the default accent colour. But the infrastructure is there: tapping a feed will bring up the entries for that feed. This is using named routes for navigation, and cubits for state management. It’s a bit more work upfront, but it does make for a neater codebase.

The biggest challenge so far was getting the actual reader view working. I hoping to use the webview plugin, but when I tried adding it, I ran into a bunch of Gradle errors. These were either class version errors or dependency errors, depending on what I tried to fix it (I didn’t get screenshots, sorry). I eventually stumbled upon this Flutter Gradle plugin migration guide, and following this, along with upgrading Java to OpenJDK 25, got Gradle working again.

But I was still getting build errors. The first couple were Gradle plugins com.android.application and org.jetbrains.kotlin.android that needed to be updated. Easy stuff. And then I got this error message:

Execution failed for task ':webview_flutter_android:compileDebugJavaWithJavac'.
> Could not resolve all files for configuration ':webview_flutter_android:androidJdkImage'.
   > Failed to transform core-for-system-modules.jar to match attributes {artifactType=_internal_android_jdk_image, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
      > Execution failed for JdkImageTransform: /Users/leonmika/Library/Android/sdk/platforms/android-34/core-for-system-modules.jar.
         > Error while executing process /Users/leonmika/Applications/Android Studio.app/Contents/jbr/Contents/Home/bin/jlink with arguments {--module-path /Users/leonmika/.gradle/caches/8.10.2/transforms/575ccd1a7426c0be21d9fe3a81898be3-05a021da-a1a7-409f-a30a-bba769b57371/transformed/output/temp/jmod --add-modules java.base --output /Users/leonmika/.gradle/caches/8.10.2/transforms/575ccd1a7426c0be21d9fe3a81898be3-05a021da-a1a7-409f-a30a-bba769b57371/transformed/output/jdkImage --disable-plugin system-modules}

Running a web search on the error revealed this Stack Overflow answer, which resolve it. There were still a few complaints about the the NDK version but after all that, the app finally launched with the web-viewer.

The web-viewer, with a "hello world"-ish test HTML document

I still need to actually render the entry, plus style the HTML a bit. The immediate goal after this, once the reader view, is getting this on my phone to start playing with it. It’s just barebones for now, but I find that the sooner I can start using a project myself, the more likely I am to keep at it.

Sat, 30 Nov 2024 06:31:53 +1100

Oh, it turns out it’s an older style of referencing targets and is no longer supposed to be used. That’s a shame.

Tue, 26 Nov 2024 07:35:16 +1100

Upgraded my work laptop to Sequoia. “Love” the experience that this new version provides, especially the mouse-and-patience exercise I get in the morning. 👎

Sat, 23 Nov 2024 08:25:42 +1100

Now this is cool: Hetzner has opened up a region in Singapore. The tyranny of distance is starting to abate.

Sat, 16 Nov 2024 07:40:11 +1100

Now that my 1Password subdomain woes with Android Vivaldi has been tamed, it’s time to turn my attention to Safari:

Sat, 09 Nov 2024 13:37:44 +1100

Building out the meta elements of Cyber Burger, including the “menu du jour” a.k.a. the main menu. I’ve used food-service terms for the menu items to maintain the theme, but there is a button to switch them over to more conventional names should it be too unclear.

Sat, 02 Nov 2024 10:39:26 +1100

Title design this morning. Trying to get as close as I can to the Cyberspace Raceway font as my pixel art skills will allow for.

Sat, 26 Oct 2024 14:19:23 +1100

I finished my experiment with htmgo, building the worlds most inefficient world clock. It uses HTMX swapping to get the time from the server every second.

It’s an interesting framework. Not sure it’s fully ready yet (you can’t change the bind port, for example) but might be useful in the future.

Sun, 20 Oct 2024 08:40:16 +1100

I was poking around Dave Winer’s Software Snacks — a brilliant name for those — and I stumbled across Little Card Editor. Decided to give it a try.

Thu, 10 Oct 2024 08:05:12 +1100

I don’t use Wordpress so this war between Matt Mullenweg and WP Engine is little more than #internet-drama to fuel my amusement. But Matt’s recent actions in this battle have started dragging users into the crossfire, and this is something I absolutely do not like. First by the blocking access to the plugin directory for those using WP Engine, and now by adding childish, your-with-me-or-agents-me UI elements on the wordpress.org login page:

I had to see it for myself to believe it.

Granted, this looks to be a login form for plugins and forums, not actual blogs. But even so, Matt, is this necessary? You may have had a reason for going after WP Engine for some reason. I have no idea what those reasons are, and quite frankly, I no longer care. You start making changes to things in service of your war, I loose all respect for you.

I may not use Wordpress, but I do use software that’s now owned by Automattic, like Pocketcasts, and seeing this makes me uneasy. What’s to say that these won’t be used in a similar way in the future?

Edit: Part of me wonders now whether this checkbox was added in jest. No evidence to support that apart from seeing various posts on Mastodon (I don’t have evidence to support that it wasn’t added in jest). If so, then I am a fool for taking the bait and getting worked up about this. It is an indication of how vicious this fight looks to me though, where adding such a checkbox would seem like a genuine escalation.

Sun, 06 Oct 2024 11:14:31 +1100

I’ve spent the last week working on a small puzzle game called Coasters, where you presented with two images and a clue, and you need to guess the word or phrase. One puzzle a day, sort of like Wordle. I’ve got 10 puzzles ready to go and I may add more but no promises. Check it out if you like.

Thu, 22 Aug 2024 08:41:13 +1100

I enjoyed reading Kev Quirk’s post about building a simple journal. I’m still using Day One, but I am still thinking of moving off it. So I was inspired to build a prototype similar to Kev’s, just to see if something similar works for me. Built using Go instead of PHP, but it also uses Simple CSS.

Fri, 26 Jul 2024 15:40:33 +1100

Reddit’s decision to allow only Google to index their site will probably mean I’ll be seeing them far less often than I do — which is almost never anyway, and generally from the results of a search. So I’m recording this screenshot, which I call “Reddit in the results”, for posterity.

Edit: Turns out Ecosia sources some of their index from Google, so these Reddit links will likely remain in my searches. I guess that makes this post unnecessary. I’m going to keep it up though, for posterity of my unnecessary effort to post for posterity. 😄

Thu, 04 Jul 2024 09:51:26 +1100

Mark the date. First successful CI/CD run of a Go project running on my own Forgejo instance, running in Hetzner. 🙌

Thu, 06 Jun 2024 22:55:27 +1100

Speaking of bad UIs, volià: my first attempt at building something with Gio:

It doesn’t do anything now, but I’m hoping this will be something I can use to test NATS. I will say Gio shows promise. Not a huge range of controls to use, but having everything run in a single memory address is nice.

Fri, 24 May 2024 11:16:13 +1100

Coding standards at work calls for US English in our codebase. So I’m typing words like “color,” “initialize,” and “data center.” And it pains me. I know that’s irrational but, you know, I never claimed to be rational when it comes to things like this.

At least the spell-checker’s on my side.

Wed, 01 May 2024 12:28:45 +1100

For the last few years, I’ve been using 4/24 as the expiry date of test credit cards within Stripe. Well those days are literally in the past now.

Sat, 27 Apr 2024 10:05:10 +1100

Interesting to see Google starting to solicit reviews for apps that came with the phone, such as the… Phone.

Tue, 16 Apr 2024 09:36:27 +1100

Love the new categories feature in Scribbles. Went back and added them to the posts on Coding Bits and Workpad. They look and feel great.

Tue, 16 Apr 2024 09:13:54 +1100

Took a while to troubleshoot why my shell script wasn’t running in Keyboard Maestro. Turns out I needed to add #!/bin/zsh -l to launch it with ZSH, with the -l switch to read my zprofile dot file.

Wed, 13 Mar 2024 22:27:02 +1100

Blogroll ported to Micro.blog and placed in a sidebar on the post list screen using Tiny Theme Microhooks. I’ve yet to port the Blogroll page, and may trim some of the recommendations appearing in the sidebar, but not bad for a first pass.

Photo Bucket Update: Exporting To Zip

Sat, 09 Mar 2024 10:33:57 +1100

Worked a little more on Photo Bucket this week. Added the ability to export the contents of an instance to a Zip file. This consist of both images and metadata.

I’ve went with lines of JSON file for the image metadata. I considered a CSV file briefly, but for optional fields like captions and custom properties, I didn’t like the idea of a lot of empty columns. Better to go with a format that’s a little more flexible, even if it does mean more text per line.

As for the images, I’m hoping the export to consist of the “best quality” version. What that means will depend on the instance. The idea is to have three tiers of image quality managed by the store: “original”, “web”, and “thumbnail”. The “original” version is the untouched version uploaded to the store. The “web” version is re-encoded from the “original” and will be slightly compressed with image metadata tags stripped out. The “thumbnail” version will be a small, highly compressed version suitable for the thumbnail. There is to be a decision algorithm in place to get an image given the desired quality level. For example, if something needed the “best quality” version of an image, and the “original” image is not available, the service will default to the “web” version (the idea is that some of these tiers will be optional depending on the need of the instances).

This is all partially working at the moment, and I’m hoping to rework all this when I replace how stores and images relate to each other (This is what I’m starting on now, and why I built export now since this will be backwards incompatible). So for the moment the export simply consists of the “web” version.

I’ve got unit tests working for this as well. I’m trying a new approach for unit testing in this project. Instead of using mocks, the tests are actually running against a fully instantiated versions of the services. There exists a servicestest package which does all the setup (using temporary directories, etc) and tear down of these services. Each individual unit test gets the services from this package and will run tests against a particular one.

This does mean all the services are available and exercised within the tests, making them less like unit tests and more like integrations tests. But I think I prefer this approach. The fact that the dependent services are covered gives me greater confidence that they’re working. It also means I can move things around without changing mocks or touching the tests.

That’s not to say that I’m not trying to keep each service their own component as much as I can. I’m still trying to follow best practice of component design: passing dependencies in explicitly when the services are created, for example. But setting them all up as a whole in the tests means I can exercise them while they serve the component being tested. And the dependencies are explicit anyway (i.e. no interfaces) so it makes sense keeping it that way for the tests as well. And it’s just easier anyway. 🤷

Anyway, starting rework on images and stores now. Will talk more about this once it’s done.

Photo Bucket Update: More On Galleries

Tue, 05 Mar 2024 22:43:05 +1100

Spent a bit more time working on Photo Bucket this last week¹, particularly around galleries. They’re progressing quite well. I’m made some strides in getting two big parts of the UI working now: adding and removing images to galleries, and re-ordering gallery items via drag and drop.

I’ll talk about re-ordering first. This was when I had to bite the bullet and start coding up some JavaScript. Usually I’d turn to Stimulus for this but I wanted to give HTML web components a try. And so far, they’ve been working quite well.

The gallery page is generated server-side into the following HTML:

<main>
  <pb-draggable-imageset href="/_admin/galleries/1/items" class="image-grid">
    <pb-draggable-image position="0" item-id="7">
      <a href="/_admin/photos/3">
        <img src="/_admin/img/web/3">
      </a>
    </pb-draggable-image>
        
    <pb-draggable-image position="1" item-id="4">
      <a href="/_admin/photos/4">
        <img src="/_admin/img/web/4">
      </a>
    </pb-draggable-image>
        
    <pb-draggable-image position="2" item-id="8">
      <a href="/_admin/photos/1">
        <img src="/_admin/img/web/1">
      </a>
    </pb-draggable-image>        
  </pb-draggable-imageset>
</main>

Each <pb-draggable-image> node is a direct child of an <pb-draggable-imageset>. The idea is that the user can rearrange any of the <pb-draggable-image> elements within a single <pb-draggable-imageset> amongst themselves. Once the user has moved an image onto to another one, the image will signal its new position by firing a custom event. The containing <pb-draggable-imageset> element is listening to this event and will respond by actually repositioning the child element and sending a JSON message to the backend to perform the move in the database.

A lot of this was based on the MDN documentation for drag and drop and it follows the examples quite closely. I did find a few interesting things though. My first attempt at this was to put it onto the <pb-draggable-image> element, but I wasn’t able to get any drop events when I did. Moving the draggable attribute onto the <a> element seemed to work. I not quite sure why this is. Surely I can’t think of any reason as to why it wouldn’t work. It may had something else, such as how I was initialising the HTTP components.

Speaking of HTML components, there was a time where the custom component’s connectedCallback method was being called before the child <a> elements were present in the DOM. This was because I had the <script> tag in the the HTML head and configured to be evaluated during parsing. Moving it to the end of the body and loading it as a module fixed that issue. Also I found that moving elements around using element.before and element.after would actually call connectedCallback and disconnectedCallback each time, meaning that any event listeners registered within connectedCallback would need to be de-registered, otherwise events would be handled multiple times. This book-keeping was slightly annoying, but it worked.

Finally, there was moving the items with the database. I’m not sure how best to handle this, but I have that method that seems to work. What I’m doing is tracking the position of each “gallery item” using a position field. This field would be 1 for the first item, 2 for the next, and so on for each item in the gallery. The result of fetching items would just order using this field, so as long as they’re distinct, they don’t need to be a sequence incrementing by 1, but I wanted to keep this as much as possible.

The actual move involves two update queries. The first one will update the positions of all the items that are to shift left or right by one to “fill the gap”. The way it does this is that when an item is moved from position X to position Y, the value of position between X and Y would be changed by +1 if X > Y, or by –1 if Y > X. This is effectively the same as setting position X to X + 1, and so on, but done using one UPDATE statement. The second query just sets the position of item X to Y.

So that’s moving gallery items. I’m not sure how confident I am with this approach, but I’ve been testing this, both manually and by writing unit tests. It’s not quite perfect yet: I’m still finding bugs (I found some while coming up with these screencasts). Hopefully, I’ll be able to get to the bottom of them soon.

The second bit of work was to actually add and remove images in the gallery themselves. This, for the moment, is done using a “gallery picker” which is available in the image details. Clicking “Gallery” while viewing an image will show the list of galleries in the system, with toggles on the left. The galleries an image already belongs to is enabled, and the user can choose the galleries they want the image to be in by switching the toggles on and off. These translate to inserts and remove statements behind the scenes.

The toggles are essentially just HTML and CSS, and a bulk of the code was taken from this example, with some tweaks. They look good, but I think I may need to make them slightly smaller for mouse and keyboard.

I do see some downside with this interaction. First, it reverses the traditional idea of adding images to a gallery: instead of doing that, your selecting galleries for an image. I’m not sure if this would be confusing for others (it is modelled on how Google Photos works). Plus, there’s no real way to add images in bulk. Might be that I’ll need to add a way to select images from the “Photos” section and have a dialog like this to add or remove them all from a gallery. I think this would go far in solving both of these issues.

So that’s where things are. Not sure what I’ll work on next, but it may actually be import and export, and the only reason for this is that I screwed up the base model and will need to make some breaking changes to the DB schema. And I want to have a version of export that’s compatible with the original schema that I can deploy to the one and only production instance of Photo Bucket so that I can port the images and captions over to the new schema. More on this in the future, I’m sure.

Apparently I’m more than happy to discuss work in progress, yet when it comes to talking about something I’ve finished, I freeze up. 🤷 ↩︎

Mon, 04 Mar 2024 07:02:05 +1100

Signed up as a lifetime member to Scribbles. Given how fun it is to use, it was an easy decision. Fantastic work, Vincent.

Mon, 12 Feb 2024 22:25:51 +1100

Spent some time this evening working on my image hosting tool. It’s slowly coming along, but wow do I suck at UI design (the “Edit Photo” screen needs some rebalancing).

Test Creek: A Test Story With Evergreen.ink

Thu, 07 Dec 2023 22:34:57 +1100

Had a play with Evergreen.ink this afternoon. It was pretty fun. Made myself a test story called Test Creek which you can try out (the story was written by me but all the images were done using DALL-E).

The experience was quite intuitive. I’ve yet to try out the advanced features, like the Sapling scripting engine, but the basics are really approachable for anyone not interested with any of that.

I would recommend not writing too much on a single card. Keep it to maybe two or three paragraphs. Otherwise the text will start to flow over the image, like it does on one of the cards in this story. Evergreen.ink does keep the text legible with a translucent background. But still, it’s just too much text.

I should also say that the preview, to the right of the editor, is interactive, meaning that you can use it to jump to cards backed by the options. While I was playing around, I was wondering why there wasn’t a quick way to do this. It wasn’t until I started writing this post that I actually tried the option in the preview, and it worked.

As for the app itself, if I could make one improvement, it would be something like an image picker which would allow me to reuse images already attached to other cards. I’m not sure how best to use images in these types of stories, but the way I was going for was more to accent the story instead of simply illustrating what’s going on in the prose. So I wanted to reuse images over a series of related cards, and in order to do that I had to upload duplicates.

But really, this is quite a minor quibble. On the whole I was quite impress by how well the experience was. It’s not easy trying to express something as complex as an interactive story, and I think Evergreen.ink did a pretty decent job.

So yeah, give it a try. It was quite fun putting this interactive story together. I haven’t got any other ideas lined up, but it would be good to make another one down the line.

Edit: One other thing to be aware of is that the link given to you when you try to share a story requires a login. So if you want to avoid that, you’ll need to choose the Zip option, which basically bundles the story as a static website. You can deploy it to Netlify quite easily (just check the permissions of the files first, I had to chmod 666 them). Thank-you Robb for letting me know.

Also, thank-you to omg.lol for the Switchboard feature. It saved my tale dealing with the new redirect.

Idea For Mainboard Mayhem: A Remote Pickup

Sun, 19 Nov 2023 21:21:56 +1100

Sort of in-between projects at the moment so I’m doing a bit of light stuff on Mainboard Mayhem. I had an idea for a new element: a remote control which, when picked up, will allow the player to toggle walls and tanks using the keyboard, much like the green and blue buttons.

I used ChatGGT to come up with some artwork, and it produced something that was pretty decent.

Prompt: pixel art of a remote control with a single red button styled like the tiles found in Chips Challange, rotated 45 degrees to the right.

Only issue was that the image was huge — 1024 x 1024 — and the tiles in Mainboard Mayhem were only 32 x 32.

I tried shrinking it down in Acorn, using various scaling algorithms. The closest that worked was bringing it down slowly to about 128 x 128 using Nearest Neighbour, than trying to go all the way down to 32 x 32 using Lanczos. That worked, but it required true 32 bit colour to be recognisable, and I wanted to preserve the 16 colour palette used by the original Chips Challenge.

So using the original image as a reference, I bit the bullet and drew my own in Acorn. You can see it here in this test level:

They're the elements that look like remote controls.

It turn out okay. At least it’s recognisable. Anyway, I coded it up and gave it a bit of a try:

Yeah, it works well. When the player has the appropriate colour remote, they can hit either Z or X to toggle the green walls or blue tanks respectively. I really should add some indicators in the status bar to show which button to press.

Not sure what I’ll do after this. The fun part was coming up with the element. But I guess I’ll have to come up with a few puzzles that use it.

Sun, 15 Oct 2023 16:52:50 +1100

More work on Mainboard Mayhem today. Had a bit more success getting the Windows build into a releasable state.

First thing was the app icon. That blog post I talked about yesterday worked: I was able to set the icon of the executable. I did make a slight adjustment though. The post suggested using ImageMagick to produce the ICO file, but I wasn’t happy with how they looked. There were a lot of artefacts on the smaller icon sizes.

So I looked around for an alternative, and found this package by Lea Anthony. He’s the maintainer of Wails, a cross-platform toolkit for making browser-based GUI apps in Go, sort of like Electron but without bundling Chrome. In fact, most of the build for Mainboard Mayhem was put together by reading the Wails source code, so I trust he knows what his doing. And sure enough, his package produced a nicely scaled ICO file from a source PNG image. Better yet, it was distributed as a Go package, so I could no need to install and shell-out to run it: I could just integrated it directly into the project’s build tool.

Using rsrc to generate the SYSO file with the icon worked as expected: Go did pick it up and embed it into the executable. I did have some trouble getting the Go compiler to pick up these files at first. In short, they need to be in the same directory as the main package. So if you’re running go build ./cmd/thing, make sure the SYSO files are in ./cmd/thing. Other than that, no real issues here.

A beautiful site: Mainboard.exe with the embedded app icon

One last thing I had to deal with was the console window. Running a Go app in Windows shows the console by default. Perfectly fine for command line tools, but less so for games:

Mainboard Mayhem with that annoying console window. Even the log messages are dull (well, unless you're working on the app).

So I had to find a way to hide the console on launch. Since Mainboard Mayhem is using SDL, I’m actually using MinGW to cross-compile the Windows release on an Ubuntu build runner. The documentation for MinGW suggests adding -mwindows as a linker option to hide the console:

# What I was doing before, which didn't work
CGO_ENABLED=1 \
CC="x86_64-w64-mingw32-gcc" \
GOOS="windows" \
CGO_LDFLAGS="-mwindows -L…" \
go build -o dist/cclm/mainboard.exe ./cmd/cclm'

This didn’t actually work when I tried it: launching the app kept bringing up the console. Turns out what I should’ve done was follow the advice of many Stack Overflow answers, and set -ldflags "-H=windowsgui" on the Go command:

# This works
CGO_ENABLED=1 \
CC="x86_64-w64-mingw32-gcc" \
GOOS="windows" \
CGO_LDFLAGS="-L…" \
go build -ldflags "-H=windowsgui" -o dist/cclm/mainboard.exe ./cmd/cclm'

This works even without the -mwindows switch. Not completely sure why though. I guess MinGW is not actually being used for linking? Or maybe -m only works with C header files? Don’t know. 🤷 But doesn’t matter: the console no longer shows up on launch.

Mainboard Mayhem without the console window. A much nicer experience now.

Finally, there was testing it all, and for this I just bit the bullet and set-up a Windows 10 virtual machine in Azure. The rate is something like $0.16 AUD an hour, an easy decision compared to spending time trying to get a VM with Windows 10 running on my machine.

One remaining thing that’s slightly annoying is Windows Defender refusing to launch it after download, doing effectively the same thing as Gatekeeper on MacOS does:

Gatekeeper a.la. Microsoft.

I’m sure there’s a way around it but it’s probably not worth learning about it at this stage. It’s easy enough to dismiss: click “More Info” and the click “Run Anyway”:

Clicking 'More Info' gives you a way to launch the app.

But other than that, I think the Windows version of Mainboard Mayhem is ready. I’ve updated the website to include the Windows archive if anyone’s interested.

Sat, 14 Oct 2023 22:20:04 +1100

Spent some time today on Mainboard Mayhem, trying to finish the Windows build. I’ve actually got Windows version of the game being built for a while now. I just haven’t published them, mainly because I haven’t got the app icon set-up yet.

But this week, Golang Weekly had a link to a blog post by Mahmud Ridwan on how to do so. It looked pretty straightforward, so I thought I’d give it a try.

And yeah, the instructions themselves were easy enough, and I wish I could say if they worked or not. But in order to test it, I need a Windows machine. And I don’t have one, and I wasn’t about to get one just for this.

So I tried setting up Windows in a VM using UTM. I got this far:

Yeah, this infinite spinner has been staring at me pretty much all day. I got a Windows 10 installer ISO using CrystalFetch, and it seemed to work. But it just doesn’t want to boot up for the first time.

Not actually sure what the problem is. The error message seems to suggest that it’s having trouble connecting to the internet. Might be that? Or maybe the installation didn’t complete properly? Could be anything. 🤷

So no luck getting this tested yet. I’m wondering if it might be easier to forget virtualisation and just launch a Windows instance in the cloud somewhere instead.

Fri, 13 Oct 2023 21:19:38 +1100

Installed the latest version of Android today. One obvious change: the calculator app displays fractions in the result. And there’s no way to turn it off.

This… doesn’t appeal to me. Not enough for me to change apps, at least not yet. But I wish there was a setting to change it back to decimals.

Sun, 17 Sep 2023 17:10:13 +1100

Spent some time today building a site for my Go utility packages. A feature I’ve decided to add is a Go template playground, where you can test out Go templates in the browser. Not something I’ll use everyday but I’ve occasionally wished for something like this before. Could be useful.

Mainboard Mayhem

Wed, 30 Aug 2023 23:27:50 +1100

Project update on Mainboard Mayhem, my Chip’s Challenge fan game. I didn’t get it finished in time for the release deadline, which was last weekend. I blame work for that. We’re going through a bit of a crunch at the moment, and there was a need to work on the weekend.

The good news is that there wasn’t much left to do, and after a few more evenings, I’m please to say that it’s done. The game is finish, and ready for release.

So here it is: Mainboard Mayhem: A Chip’s Challenge fan game (and yes, that’s its full title).

At the moment it’s only available for MacOS. It should work on both Intel and Apple Silicon Macs, although I’ve only tested on my M2 Mac Mini running Ventura.

It’s good to finally see this project done. It’s been in development for about last ten years, and I spent half of that time wondering whether it was worth getting it finished it at all. Not committing to anything meant any work I did do on it was pretty aimless, and I always felt like I was wasting my time. Giving myself three weeks to either kill it, or release it helped a lot. I’ll start making deadlines for all the other unfinished projects I’m working on.

As to what that next project will be, I not sure at this stage. Part of me wants to wait until this crunch time ends, but I suspect I’ll get antsy before then and start work on something else. I’ll keep you posted one way or the other.

But for now, if you happen to give it a try, thank you and I hope you enjoy it.

Sun, 20 Aug 2023 12:00:37 +1100

Project update for Mainboard Madness. Well, today’s the deadline for getting the thing code complete, and what a surprised, it’s not finished.

To be fair, it’s pretty close. All the levels are more or less done, and the beats of the in-game lore have been added. It all just needs tightening up a little. I spent today working on the end-game phase, which mainly involved coding up the credit sequence, and making sure I include credits for those involved in the original game (and who’s artwork I lifted).

The work remaining is to finish one or two game elements, adding a proper app icon, and finishing off the website. I’m wondering whether to add sound, but I feel bad enough taking the artwork from the original game, I rather not take the sound effects as well. That will mean the game will remain silent for the time being, but I can probably live with that for now.

I think we’re still on track for getting this finished by this time next week. Last dash to the finish line, then I can put this 9 year project to rest for a while.

Sat, 05 Aug 2023 14:43:19 +1100

Working on my Chips Challenge “fan game” this morning. Added the notion of “lower thirds,” which will show text at the bottom of the play field. I’m hoping to use it for narrative or way-finding, like here in this hub level:

Also working on puzzle design. There’s about 19 or so “real” puzzles but I’m wondering if it’s worth adding a few tutorial ones for those that have never played the original Chip Challenge before. I’ve done about 5 such puzzles and I think I need to add maybe 3 or 4 more to cover everything I’m hoping to demonstrate. I wish I liked puzzle design more than I like tinkering on the engine.

Of course, the big question is why I’m working on this at all. There is, for lack of a better word, a vision for this, in terms of narrative and structure, but this project has been in development on and off for about 9 years or so, and I’m wondering if it’s time to just stop working on it altogether. I really am starting to get sick of it, in a way. And yet, this project has shown remarkable staying power over that time that I feel like if I don’t actually wrap it up, it’ll just continued to be worked on. It feels like the only way to end this project is to finish it, in one way or another.

So I’ll set myself a dead-line: something releasable in two weeks, and actually released a week after that. After that, no more! I’ll work on something else.

Sat, 29 Jul 2023 11:28:48 +1100

Attempting to design an app icon for a Chips Challenge fan game I’m working on. Going for something that looks like the fireball sprite in the original game with a hint more realism and tinted in the colour blue. For reference, here’s the original fireball sprite:

And here’s my attempt:

I started with Stable Diffusion to get the base image:

Prompt: a blue plasma fireball shaped like a throwing star with four points on a white background, pixel art

Then imported into Acorn to rotate it, colourise it, and distort it to look a bit closer to the original sprite.

Desaturating the original image got rid of the purple centre, then applying the Glowhoo and Hue Adjust effect recolourised it to the blue I was looking for (I’m not sure what the Glowhoo effect does, but it seems to adjust the colour based on the pixel intensity, so it was good enough for what I wanted). Finally, I added a Twirl Distortion effect to achieve the slight warp in the star.

And yeah, it’s not going to win any design awards, but it’s good enough for now.

Oh, and just for kicks, here was my first attempt of producing the sprite using Affinity Designer.

That’s definitely not going to win any design awards. 😂

Tue, 25 Jul 2023 09:55:24 +1100

For reasons that are “totally” coincidental to the news of the day, I had a quick check to see how much the domain Y would cost:

Hmm, might be a bit much for a joke domain. 😃

Sat, 22 Jul 2023 10:34:52 +1100

A really nice quality of life improvement you can make in Terminal.app: map Option-Backspace to ^W (Control-W, or \027) so that pressing it in the shell will delete one word to the left, like most other MacOS apps:

Sat, 01 Jul 2023 11:51:41 +1100

TIL you can enter a photo description in Google Photos. Select a photo, click the Info icon, and a free-text “description” field is revealed. Not super sure what the description is to be used for, but I’m hoping to use it for photo captions.

Sun, 21 May 2023 22:52:03 +1100

I’ve been working on Micropub Checkins over the last week. It’s been a bit of a rush trying to get it into a usable state for an upcoming trip. And by “usable”, I mean a form that I can tolerate, and when it comes to projects like this, I can tolerate quite a lot. It can have a really dodgy UI (which this does) and miss some really important features that are annoying to work around; but if it works, and doesn’t loose data, I’ll be fine with it.

The main screen showing the recent check-ins. Note the lock next to some of them. These won't be published until the locks are removed.

The last week was dedicated to making the act of checking in distinct from publishing it. Until now, check-ins were published the minute they were entered, meaning that you cannot check-in somewhere unless you’re comfortable with people knowing where you are the minute you do. Yes, some people like it that way, but not me. And I’m aware that this’ll only be the case if people are following my check-in blog, which I’m doubtful of.

So pressing the floating action button and choosing a check-in type now starts the flow of a new check-in that will get saved in an SQLite database. You can edit the check-in whenever you like, so long as it’s not published. Currently there’s no real way of deleting a check-in unless it’s been published. This is a bit dodgy, but it’s a good example of how tolerant I am with working around these feature gaps for the moment.

The newly styled edit screen. Notice the rating field, which will appear for eateries.

Check-ins can be published by tapping the upward facing button on the main screen. Any check-in with a lock is private and will not be published until you toggle the “Ready to publish” switch in the properties. Doing so will not change the date of the check-in: it will still have the date and time that check-in was created.

The targets are currently hard-coded but they can be turned on or off. I had a bit of trouble publishing a check-in to two targets, so I'm not sure if I'll keep multi-target publishing.

On the subject of publishing, I had some issues with Dart’s date and time methods. The method on the DateTime class used to produce an ISO-8501 date-stamp don’t include the time-zone if the date and time is not in UTC. This is important as I want the post date and time to be as close to the check-in time as possible, and in the time-zone of the phone. DateTime knows all this, including what the time-zone we’re in. So why didn’t the developers include it in the ISO-8501 date-time string?

This is really strange. Fortunately, ChatGPT stepped in to help out, writing a function which will add the time-zone offset to the ISO-8501 date-time string:

String formatTimeZoneOffset(Duration offset) {
  String sign = offset.isNegative ? '-' : '+';
  int hours = offset.inHours.abs();
  int minutes = (offset.inMinutes.abs() % 60);

  return '$sign${_padZero(hours)}:${_padZero(minutes)}';
}

Honestly, ChatGPT has been so helpful over the past week with this project, I probably should give it a credit if I get this polished enough to release.

Tue, 16 May 2023 17:29:46 +1100

I got a little bored today so I added task progress indicators to this Obsidian roadmap thing I built for work.

What the task progress indicators look like.

When a task is created, but is not yet scheduled, it appears as an outlined rectangle. It turns into a grey rectangle when it’s added to the sprint. It then changes colour as the task progresses through the software lifecycle; turning purple while it’s being developed, blue while it’s being tested, and finally green when it’s ready for release.

They’re implemented as embedded SVG images, added directly to the note much like the span element used for status labels.

Move the insertion point over the the SVG image to edit the markup.

It’s nice being able to add embellishments like this. Obsidian treating notes as regular files on the file-system is a huge advantage for these sorts of automations. No need to learn how to make a plugin; just write a shell script¹ that’ll output Markdown, schedule it to run a couple of times a day, and you’re good to go.

The “shell script” is actually written in Go, using the really useful script package to simplify all the pipelining stuff. ↩︎

Sat, 13 May 2023 13:25:17 +1100

Back working on Micropub Checkin. Re-engineered the home page to now include a list of what would eventually be check-ins — both historical and soon to be published — complete with the check-in type emoji as the icon:

Main screen for Micropub Checkin

The same list of emoji icons now adorn the check-in type picker as well (except for the airplane one which seems to always be shown as what I can only describe as the “Wingding” representation):

The check-in type picker

I went around a bit trying to work out how best to use these emojis icons in the leading slot of the ListTile widget. I expored trying to convert them to IconData, but it turns out just using a Text widget with a large font worked well. I wrapped in in a Widget type with a fixed font-size and so far it looks quite good, at least in the emulator:

class EmojiIcon extends StatelessWidget {
  final String emoji;

  const EmojiIcon({super.key, required this.emoji});

  Widget build(BuildContext context) {
    return Text(emoji, style: TextStyle(fontSize: 26.0));
  }
}

Also started working on a Cubit to handle state for the main page. I had a bit of trouble working ont where the soon-to-be database call to get the list of checkins should go in the cubit. After asking ChatGPT, it looks like the initializer is the best place for it:

class CheckinListCubit extends Cubit<CheckinListState> {

  CheckinListCubit(): super(LoadingCheckinListState()) {
    loadCheckinList();
  }

  void loadCheckinList() async {
    var listOfCheckins = await read_database(); 
    emit(FoundCheckinListState(checkins));
  }
}

I’ve got some scaffolding code in place to simulate this, and so far it seems to work.

I need to start working on the database layer and having the ability to edit and delete check-ins before they’re published. I think I’ll tackle that next.

Sat, 13 May 2023 11:00:00 +1100

Does this loading window really need to be modal?

Sun, 30 Apr 2023 15:17:15 +1100

Hmm, either Daniel is super obsessed with the Beths (or at least posting about it), or there’s a bug somewhere. 😀

Building F5 To Run

Sun, 16 Apr 2023 11:36:18 +1100

At the risk of talking about something that I’ve only just started, I’d thought today I write about what I’m working on right now.

I’ve been going through my digital archives this weekend, trying to get it into something more permenant than the portable USB drives it’s currently stored on. Amongst all that stuff is a bunch of QBasic apps and games I wrote way back when I was a kid. Over the years it’s laid dormant but I do like revising them from time to time.

Is it a form of nostalgia? An attempts to live past glories? Maybe? I was pretty proud of them at the time, much like anyone else that’s proud of their early stuff while they’re leaning to code. And I know about the risk of living in the past at the expense of the present. But I also know that if I get rid of them, I’d regret it. I already regret loosing the things from the archive so far, due to bad disks or just missing things while copying them from portable hard-drive to portable hard-drive. I don’t want to loose any more.

So in an act of posterity, I’d figured it’s time to coat them in amber and put them online. So that’s what I’m doing now.

These apps run without issue in DosBox, and hearing about how the Wayback Machine has managed to make a bunch of DOS games playable within the browser, I wondered if I could do something similar. Anything that deals with virtualisation is always going to be a little bit involved. I guess one thing going for these is that they were written for a pretty slow machine and a pretty thin OS that would be trivial for modern hardware to emulate. The apps themselves, even compiled to an EXE file, are not very taxing on the hardware back then either. But I still expected to do a bit of heavy lifting myself.

How wrong I was! After a tiny bit of research — and by tiny I mean one Ecosia search — I managed to find a JavaScript library called JS-Dos which provides a DosBox emulator that’s runnable from a browser. All I need to do is prepare a bundle on what I want to run (more on that below) and with a bit of JavaScript, I can start a DosBox machine in the browser and mount it to a HTML element. The library does all the work.

How To Use JS-Dos

It’s still early days, but here’s what I learnt about using the library so far.

First, the library comes as a NPM package, or can be loaded from their CDN in the form of a <script> import. I first tried using the NPM package, but I didn’t know the appropriate import statement to use, and the documentation was not forthcoming on this front.

So I went with the CDN approach. I’m using Hugo Pipes to fetch the remote JavaScript file and make a local bundle so I can host it from the site itself. It comes with some CSS which I also need to get (note, I’m using parenthesis instead of curly braces here as I’m not sure how to include two curly braces in a code-block).

(( $jsDosCSS := resources.GetRemote "https://js-dos.com/v7/build/releases/latest/js-dos/js-dos.css" ))
<link rel="stylesheet" href="(( $jsDosCSS.RelPermalink ))">
        
(( $jsDosJS := resources.GetRemote "https://js-dos.com/v7/build/releases/latest/js-dos/js-dos.js" ))
<script src="(( $jsDosJS.RelPermalink ))" defer></script>

I also needed to get an appropriate wdosbox emulator. This comes in the form of a WASM file, plus a small JavaScript file which I assume is some simple bootstrapper. I’ve downloaded these and stored them in the static/emulators directory of my Hugo project. The JSDos library loads them on demand and I needed to set the URL path prefix for these two files so that JSDos knows where to get them:

emulators.pathPrefix = '/emulators/';

Next, I needed to build a bundle. These are the DOS programs that are launched with DosBox. They’re effectively just Zip files holding some metadata, the DOS executable, and any files needed for the program to run. There’s some basic information about how to make them, and there’s even an online tool which will take on a lot of the tedious work. I’ve used it to make a couple of test bundles and it works quite well. I’d like to eventually make my bundles myself but I’ll stick with the tool for the time being, at least until I’ve got a DosBox configuration that I’m happy with. One thing the tool does is give you the ability to define an overlay so that these DOS apps are usable from within a mobile browsers. I’ll see if I can get away from needing these overlays at this stage. I’m not expecting anyone with a mobile app to try these out.

The contents of .jsdos/dosbox.conf for the test bundle `logo-2.jsdos`

[sdl]
autolock=false

fullscreen=false
fulldouble=false
fullresolution=original
windowresolution=original
output=surface
sensitivity=100
waitonerror=true
priority=higher,normal
mapperfile=mapper-jsdos.map
usescancodes=true
vsync=false
[dosbox]
machine=svga_s3

language=
captures=capture
memsize=16
[cpu]
core=auto
cputype=auto
cycles=max

cycleup=10
cycledown=20
[mixer]
nosound=false
rate=44100

blocksize=1024
prebuffer=20

[render]
# frameskip: How many frames DOSBox skips before drawing one.
#    aspect: Do aspect correction, if your output method doesn't support scaling this can slow things down!.
#    scaler: Scaler used to enlarge/enhance low resolution modes.
#              If 'forced' is appended, then the scaler will be used even if the result might not be desired.
#            Possible values: none, normal2x, normal3x, advmame2x, advmame3x, advinterp2x, advinterp3x, hq2x, hq3x, 2xsai, super2xsai, supereagle, tv2x, tv3x, rgb2x, rgb3x, scan2x, scan3x.

frameskip=0
aspect=false
scaler=none

[midi]
#     mpu401: Type of MPU-401 to emulate.
#             Possible values: intelligent, uart, none.
# mididevice: Device that will receive the MIDI data from MPU-401.
#             Possible values: default, win32, alsa, oss, coreaudio, coremidi, none.
# midiconfig: Special configuration options for the device driver. This is usually the id of the device you want to use.
#               See the README/Manual for more details.

mpu401=intelligent
mididevice=default
midiconfig=

[sblaster]
#  sbtype: Type of Soundblaster to emulate. gb is Gameblaster.
#          Possible values: sb1, sb2, sbpro1, sbpro2, sb16, gb, none.
#  sbbase: The IO address of the soundblaster.
#          Possible values: 220, 240, 260, 280, 2a0, 2c0, 2e0, 300.
#     irq: The IRQ number of the soundblaster.
#          Possible values: 7, 5, 3, 9, 10, 11, 12.
#     dma: The DMA number of the soundblaster.
#          Possible values: 1, 5, 0, 3, 6, 7.
#    hdma: The High DMA number of the soundblaster.
#          Possible values: 1, 5, 0, 3, 6, 7.
# sbmixer: Allow the soundblaster mixer to modify the DOSBox mixer.
# oplmode: Type of OPL emulation. On 'auto' the mode is determined by sblaster type. All OPL modes are Adlib-compatible, except for 'cms'.
#          Possible values: auto, cms, opl2, dualopl2, opl3, none.
#  oplemu: Provider for the OPL emulation. compat might provide better quality (see oplrate as well).
#          Possible values: default, compat, fast.
# oplrate: Sample rate of OPL music emulation. Use 49716 for highest quality (set the mixer rate accordingly).
#          Possible values: 44100, 49716, 48000, 32000, 22050, 16000, 11025, 8000.

sbtype=sb16
sbbase=220
irq=7
dma=1
hdma=5
sbmixer=true
oplmode=auto
oplemu=default
oplrate=44100

[gus]
#      gus: Enable the Gravis Ultrasound emulation.
#  gusrate: Sample rate of Ultrasound emulation.
#           Possible values: 44100, 48000, 32000, 22050, 16000, 11025, 8000, 49716.
#  gusbase: The IO base address of the Gravis Ultrasound.
#           Possible values: 240, 220, 260, 280, 2a0, 2c0, 2e0, 300.
#   gusirq: The IRQ number of the Gravis Ultrasound.
#           Possible values: 5, 3, 7, 9, 10, 11, 12.
#   gusdma: The DMA channel of the Gravis Ultrasound.
#           Possible values: 3, 0, 1, 5, 6, 7.
# ultradir: Path to Ultrasound directory. In this directory
#           there should be a MIDI directory that contains
#           the patch files for GUS playback. Patch sets used
#           with Timidity should work fine.

gus=false
gusrate=44100
gusbase=240
gusirq=5
gusdma=3
ultradir=C:\ULTRASND

[speaker]
# pcspeaker: Enable PC-Speaker emulation.
#    pcrate: Sample rate of the PC-Speaker sound generation.
#            Possible values: 44100, 48000, 32000, 22050, 16000, 11025, 8000, 49716.
#     tandy: Enable Tandy Sound System emulation. For 'auto', emulation is present only if machine is set to 'tandy'.
#            Possible values: auto, on, off.
# tandyrate: Sample rate of the Tandy 3-Voice generation.
#            Possible values: 44100, 48000, 32000, 22050, 16000, 11025, 8000, 49716.
#    disney: Enable Disney Sound Source emulation. (Covox Voice Master and Speech Thing compatible).

pcspeaker=true
pcrate=44100
tandy=auto
tandyrate=44100
disney=true

[joystick]
# joysticktype: Type of joystick to emulate: auto (default), none,
#               2axis (supports two joysticks),
#               4axis (supports one joystick, first joystick used),
#               4axis_2 (supports one joystick, second joystick used),
#               fcs (Thrustmaster), ch (CH Flightstick).
#               none disables joystick emulation.
#               auto chooses emulation depending on real joystick(s).
#               (Remember to reset dosbox's mapperfile if you saved it earlier)
#               Possible values: auto, 2axis, 4axis, 4axis_2, fcs, ch, none.
#        timed: enable timed intervals for axis. Experiment with this option, if your joystick drifts (away).
#     autofire: continuously fires as long as you keep the button pressed.
#       swap34: swap the 3rd and the 4th axis. can be useful for certain joysticks.
#   buttonwrap: enable button wrapping at the number of emulated buttons.

joysticktype=auto
timed=true
autofire=false
swap34=false
buttonwrap=false

[serial]
# serial1: set type of device connected to com port.
#          Can be disabled, dummy, modem, nullmodem, directserial.
#          Additional parameters must be in the same line in the form of
#          parameter:value. Parameter for all types is irq (optional).
#          for directserial: realport (required), rxdelay (optional).
#                           (realport:COM1 realport:ttyS0).
#          for modem: listenport (optional).
#          for nullmodem: server, rxdelay, txdelay, telnet, usedtr,
#                         transparent, port, inhsocket (all optional).
#          Example: serial1=modem listenport:5000
#          Possible values: dummy, disabled, modem, nullmodem, directserial.
# serial2: see serial1
#          Possible values: dummy, disabled, modem, nullmodem, directserial.
# serial3: see serial1
#          Possible values: dummy, disabled, modem, nullmodem, directserial.
# serial4: see serial1
#          Possible values: dummy, disabled, modem, nullmodem, directserial.

serial1=dummy
serial2=dummy
serial3=disabled
serial4=disabled

[dos]
#            xms: Enable XMS support.
#            ems: Enable EMS support.
#            umb: Enable UMB support.
# keyboardlayout: Language code of the keyboard layout (or none).

xms=true
ems=true
umb=true
keyboardlayout=auto

[ipx]
# ipx: Enable ipx over UDP/IP emulation.

ipx=true
[autoexec]
echo off
mount c .
c:

type jsdos~1/readme.txt
echo on

LOGO.EXE

I’m keeping the bundles in the static/bundles directory, which sits alongside the emulator WASM file. They’re not huge binaries but I’m still using git lfs to manage them. Best to keep the the Git repository relatively sane.

Finally, it’s just a matter of adding some JavaScript to start DosBox, load the bundle, and mount it onto a HTML element:

Dos(document.querySelector("#element-to-mount")).run("/bundles/bundle-to-load.jsdos");

And that’s pretty much it.

A test webpage with JSDos running Logo 2, which is one of my Basic programs

After a few hours, I’ve managed to get a test version of this working. There are a few things that need working on: the app I’m trying require the Alt key, which is not readily available of Apple keyboards, so I may need to do something about that (JSDos comes with a virtual keyboard with Ctrl and Alt so it’s not a complete show-stopper)¹. And I’ll need to get styling and more maintainable JavaScript written for this (I’m using StimulusJS for the JavaScript²). But I’m impressed by how well this works, given the minimal amount of effort from my part. Shoulders of giants and all that.

I’ve since learnt that Alt is bound to the Option key in MacOS. ↩︎
One thing I leant about Hugo is that it’s bundled with ESBuild, meaning that it’s resource pipeline supports NPM packages. My understanding is that this is invokable using the js.Build construct. This is super useful to know. ↩︎

Sun, 02 Apr 2023 10:17:43 +1100

What would be a nice addition to the spell-check suggestions menu is a brief (3-5 words) definition of the word. I always find myself choosing the wrong suggestion, and a feature like this would help a lot.

Updating Bocce Scorecard

Sun, 26 Mar 2023 11:13:43 +1100

I didn’t get to a lot of side-project work this week, but I did have to make a large change to a project we use to track scores for our “bocce club”. So I’d though I’d say a few words about that today.

We had our bocce “grand final” a few weeks ago, and one of the matches resulted in a tie between two players. Unfortunately, the Bocce Scorecard web-app I build could not properly handle these, which meant that I had to fix it.

I’ll be honest in saying that that this was never really well fleshed out in the code, and there was actually a small bug which didn’t handle the ranking of players well. But I was pushing to keep this app as the de-facto source of truth for these matches, and there was a bit riding on this being correct (there’s a $4 trophy involved). So I had to get this fix before our next match, which was today.

Now, I been having trouble coming up with a good description of what the rules should be so I’d figured a simple example would suffice.

Imagine that there are four players: Tom, Dick, Harry, and Sally. They play several bocce matches during a season — which roughly corresponds to one calendar year — plus three “grand final” matches at the end. Each player would be awarded a number of “season points” (we informally call them “cookies”) based on how well they did in the match. The person with the most season points at the end of the last grand final match wins the season, and gets to take home the trophy.

In regular matches, the wining player is awarded one season point, while the remaining players get nothing:

Player	Score	Season Points
Tom	11	1
Dick	8	0
Sally	6	0
Harry	3	0

In grand final matches, the winning player is awarded 5 points, the one coming in second gets 2, and the one coming in third gets 1:

Player	Score	Season Points
Tom	11	5
Dick	8	2
Sally	6	1
Harry	3	0

Season points for grand final matches are distributed this way so that a single grand final match is roughly equivalent to an entire season of regular matches. This means that if someone is coming in last during the regular season (fun fact: that person’s usually me) they still has a chance to win the trophy if they do well during the grand final.

Now, let’s say that our four players are playing a grand final match, and Dick and Sally tie for second place. What should happen is that both Dick and Sally should be awarded half the season points they would get for both the second and third rank, given that they are evenly match for these two positions. In other words, they should both get 1.5 season points (1 + 2 = 3 / 2 = 1.5). Harry, who came last, still gets zero.

Player	Score	Season Points
Tom	11	5
Dick	7	1.5
Sally	7	1.5
Harry	3	0

This was the rule that I needed to change.

What I found when I started working on this is that the rule definitions themselves needed to be closer to how the players are ranked. What was previously done was that the players were sorted based on their match score, and then the rules were applied to each one by checking the win condition and awarding the points if they match it. But this didn’t fit nicely with this new approach to ties.

So instead of the conditions and awards approach, I simplified the rule definitions such that it simply defines the number of season points based on the players rank. This effectively makes it a simple map between rank and points. For normal matches the mapping would look like this:

Rank	Season Points
1	1

and for grand final matches, like this:

Rank	Season Points
1	5
2	2
3	1

Now, when a match is over, the logic that awards the season points first sorts the players based on their match score, and then groups the players into buckets such that all the players with same match score are lumped together in the same bucket. Ranks are then assigned to the players in descending score order. If two players have the same score, they will be given two ranks (e.g. Dick and Sally would have both rank two and three). Finally, season points are awarded with the rule definition and the following formula:

season_points(player) = sum[over player_ranks](rules.rank_scores[rank]) / no_of_players_in_bucket

This new logic works for ties between any number of players with any ranks.

But the introduction of division now means that the season points can be a decimal, and the database row that holds the season points is an integer type. I didn’t want to make it a floating point, so I took a page from Stripe and simply changed the representation of the season scores such that 1 season point is represented as 100 in the database. This is exposed in the rules configuration, which now looks like this:

{
  "rank_scores": [
    {
      "points": 500,
      "rank": 1
    },
    {
      "points": 200,
      "rank": 2
    },
    {
      "points": 100,
      "rank": 3
    }
  ]
}

although all the non-admin screens properly represents the score as a decimal number.

I managed to get all finished and pushed to the server, but there was one other thing I think I’d like to get done down the line. My friends have been asking me about the outcome of previous seasons recently and I’d like to make it easier for them to view it themselves. The data exists, but it’s super hacky to get: you need to “open” a previous season so that the leader board is shown on the home page, then close it again once the info is seen. This can only be done by the admin user (i.e. me) and the screens to do it leave a lot to be desired:

The current season admin section.

What I’m thinking is adding a “Seasons” section in the web-app. Clicking “Seasons” in the nav will bring up the following screen:

Mockup of a new season browser section.

The game variant will appear the top as a tab, and below them are all the current and past seasons arranged in descending chronological order. Clicking the > will bring up the season results display:

Drilling down into a season brings up the details, complete with a leader board and list of matches played during that season.

This will show the final outcome of the season, any metadata associated with the season, and the matches of the season, along with the winner. Clicking the location will bring up the particular bocce session so that all the matches played that day can be seen.

We’ll see when I get around to building this. It’s actually been a while since I’ve last touched this project while making such a large feature.

Oh, and since it’s been a while, this usually means I needed to upgrade Buffalo, the framework this app is using. Doing this usually means that you’ll need to change your app in some way to handle the new build process. This time, it’s moving the main.go file, previously in the project directory, into a cmd/app directory. When you see output like this:

leonmika@Stark bocce-scorecard % buffalo build -o /tmp/app
Usage:
  buffalo build [flags]

Aliases:
  build, b, bill, install

Flags:
      --build-flags strings        Additional comma-separated build flags to feed to go build
      --clean-assets               will delete public/assets before calling webpack
      --dry-run                    runs the build 'dry'
      --environment string         set the environment for the binary (default "development")
  -e, --extract-assets             extract the assets and put them in a distinct archive
  -h, --help                       help for build
      --ldflags string             set any ldflags to be passed to the go build
      --mod string                 -mod flag for go build
  -o, --output string              set the name of the binary
  -k, --skip-assets                skip running webpack and building assets
      --skip-build-deps            skip building dependencies
      --skip-template-validation   skip validating templates
  -s, --static                     build a static binary using  --ldflags '-linkmode external -extldflags "-static"'
  -t, --tags string                compile with specific build tags
  -v, --verbose                    print debugging information

ERRO[0000] Error: open cmd/app/main.go: no such file or directory

You’ll need to create a cmd/app directory and move main.go into the cmd/app directory.

This will get the build working again but it will break buffalo dev as it could no longer find the main file in the project directory. To fix that, you’ll need to open up .buffalo.dev.yml and add the following property:

build_target_path: "./cmd/app"

This will get the dev build working again.

I don’t know why the dev command honours this config, yet the build command chooses to look at a hard coded path. Wouldn’t it have been easier to express this in a single configuration file?

And let’s not leave Node out of the cold. If you’re trying to run buffalo build and you’re getting this error:

#21 12.21 node:internal/crypto/hash:71
#21 12.21   this[kHandle] = new _Hash(algorithm, xofLen);
#21 12.21                   ^
#21 12.21 
#21 12.21 Error: error:0308010C:digital envelope routines::unsupported
#21 12.21     at new Hash (node:internal/crypto/hash:71:19)
#21 12.21     at Object.createHash (node:crypto:133:10)
#21 12.21     at BulkUpdateDecorator.hashFactory (/src/bocce_scorecard/node_modules/webpack/lib/util/createHash.js:145:18)
#21 12.21     at BulkUpdateDecorator.update (/src/bocce_scorecard/node_modules/webpack/lib/util/createHash.js:46:50)
#21 12.21     at RawSource.updateHash (/src/bocce_scorecard/node_modules/webpack/node_modules/webpack-sources/lib/RawSource.js:77:8)
#21 12.21     at NormalModule._initBuildHash (/src/bocce_scorecard/node_modules/webpack/lib/NormalModule.js:888:17)
#21 12.21     at handleParseResult (/src/bocce_scorecard/node_modules/webpack/lib/NormalModule.js:954:10)
#21 12.21     at /src/bocce_scorecard/node_modules/webpack/lib/NormalModule.js:1048:4
#21 12.21     at processResult (/src/bocce_scorecard/node_modules/webpack/lib/NormalModule.js:763:11)
#21 12.21     at /src/bocce_scorecard/node_modules/webpack/lib/NormalModule.js:827:5 {
#21 12.21   opensslErrorStack: [ 'error:03000086:digital envelope routines::initialization error' ],
#21 12.21   library: 'digital envelope routines',
#21 12.21   reason: 'unsupported',
#21 12.21   code: 'ERR_OSSL_EVP_UNSUPPORTED'
#21 12.21 }

You’ll need to enable the legacy OpenSSL provider using a Node option:

export NODE_OPTIONS=--openssl-legacy-provider

Yeah, building to a framework is always fun. 😏

So that’s it for this weeks update. I spent some time on Dynamo-Browse this week as well, but I haven’t actually finished that work and this log entry is long enough, so I might say more about that next week.

Mon, 20 Mar 2023 07:52:32 +1100

Getting some pretty strange spam emails sent to my Gmail address (which I still use). It’s the same badly formatted multi-MIME message body with different From and Subject lines. They’re trying to get… something from me? Logins, maybe? Worst phishing attempt ever!

Updates To Dynamo-Browse And CCLM

Sun, 19 Mar 2023 22:46:18 +1100

I started this week fearing that I’d have very little to write today. I actually organised some time off over the weekend where I wouldn’t be spending a lot of time on side projects. But the week started with a public holiday, which I guess acted like a bit of a time offset, so some things did get worked on.

That said, most of the work done was starting or continuing things in progress, which is not super interesting at this stage. I’ll hold off on talking about those until there’s a little more there. But there were a few things that are worth mentioning.

Dynamo-Browse

I found a bug in the query planner. It had to do with which index it chose when planning a query with only a single attribute. If a table has multiple GSIs that have that same attribute as the partition key (with different attributes for sort keys), the index the planner choose became effectively random. Because each index may have different records, running that query could give incomplete results.

I think the query planner needs to be fixed such that any ambiguity in which index to be use would result in an error. I try to avoid putting an unnecessary need for the user to know that a particular query required a particular index. But I don’t think there’s any getting around this: the user would have to specify.

But how to allow the user to specify the index to use?

The fix for the script API was reasonably simple: just allow the script author to specify the index to use in the form of an option. That’s effectively what I’ve done by adding an optional index field to the session.query() method. When set, the specific index would be used regardless of which index the query planner would choose.

I’m not certain how best to solve this when the user is running a query interactively. My current idea is that a menu should appear, allowing the user to select the index to use from a list. This could also include a “scan” option if no index is needed. Ideally this information will be stored alongside the query expression so that pressing R would rerun the query without throwing up the prompt again.

Another option is allowing the user to specify the index within the expression in some way. Maybe in the form of a hint, as in having the user explicitly specify the sort key in a way that does’t affect the output. This is a little hacky though — sort of like those optimisations you need to do in SQL queries to nudge the planner in a particular execution plan.

Another option is having the user specify the index specifically in the query. Maybe as an annotation:

color="blue" @index('color-item-index')

or as a suffix:

color="blue" using index('color-item-index')

Anyway, this will be an ongoing thing I’m sure.

One other thing I started working on in Dynamo-Browse is finally working on support for the between keyword:

age between 12 and 24

This maps directly to the between statement in DynamoDB’s query expression language, so getting scan support for this was relatively easy. I do need to make the query planner know of this though, as this operation is supported in queries if it’s used with the sort key. So this is still on a branch at the moment.

Finally, I’ve found myself using this tool a lot this last week and I desperately need something akin to what I’ve been calling a “fanout” command. This is a way to take the results of one query and use them in someway in another query — almost like sub-queries in regular SQL. What I’ve been finding myself wishing I could use this for is getting the IDs of the row from a query run over the index, and just running a query for rows with those ID over the main table. At the moment I’m left with copying the ID from the first result set, and just making a large pk in (…) expression, which is far from ideal.

I’m not sure whether I’d like to do this as a command, or extend the query expression in some way. Both approaches have advantages and disadvantages. That’s probably why I haven’t made any movement on this front yet.

CCLM

I did spend the Monday working on CCLM. I coded up a small script which took some of the ideas from the blog post on puzzle design I mention last week that I could run to get some ideas. So far it’s only producing suggestions with two game elements, but it’s enough of a starting point for making puzzles:

leonmika@Stark cclm % go run ./cmd/puzzleidea
bear trap
directional walls

After running it on Monday I had a go at starting work on a new level. It became clear reasonably soon after I started that I needed a new game element. So I added one, which I’ve called “kindling”. By default it looks like a pile of wood, and is perfectively safe to walk on:

But if a fireball runs into it, it catches alight and spreads to any adjacent kindling tiles, turning them into fire tiles.

I had an idea for this for a while. I even went to the extend of producing the graphics for this element. But needing it for this puzzle finally bought me around to finishing the work. I actually manage to make most of the changes without any changes to the Go code at all: the existing tile definition configuration was almost powerful enough to represent this tile.

One other minor thing I fixed was the alignment of the info panels on the right side of the screen. Dealing with the unaligned numbers got a bit much eventually. The cursor position, marker position, and tag numbers are properly aligned now.

Anyway, that’s all for this week.

Tue, 07 Mar 2023 09:13:06 +1100

Follow-up from my earlier post about ChatGTP this morning, it turns out I probably should’ve RTFM:

Thanks to @andreab@social.lol for the tip.

Tue, 07 Mar 2023 08:07:20 +1100

Remember in Gödel, Escher, Bach when they were saying that a (then) theoretical AI is less like a calculator and more akin to the human mind; and just like the human mind is likely to produce errors in the answers it gives? Well…

For reference, macOS Ventura is the current latest release.

Update: Turn’s out the reason for this is that ChatGTP’s data-set only goes back to Nov 2021. See follow-up post.

Sat, 04 Mar 2023 16:55:32 +1100

Here’s a bit of a blast from the past. I managed to get ccedit working again. This was the original level editor for workingset.net/2022/12/2… my Chips Challenge “fan game” I’ve been working on.

I’ve been designing a few levels for it recently, but since moving to a new Mac, the level editor I was using was going to be difficult to port. It’s QT application and the QT bindings were a pain to setup, and I rather not go through that again. I was using a Mac at the time I started working on it, but I wasn’t yet ready to go all in on MacOS. So to hedge my bets, I decided to go with QT as the UI toolkit.

This was 5 years ago and I’m unlikely to go back to Linux, so choosing QT was a bit of a bad decision. I think if I had my time again, I’d go with something like AppKit.

Anyway, the level editor still works but I have to log into a screen share to use it. I’d like to be able to edit levels on the machine I’m using now.

The code for the original level editor was still around but it hasn’t been touched in ages. It’s basically an SDL application — the same graphics library I’m using for the actual game itself — and the SDL v2 bindings I’m using are still maintained, so updating those were quite easy¹.

One thing I did have to pull out was the Lua VM². The editor was using old C Lua bindings. Better Lua VMs written in pure Go are now available, so I didn’t want to keep using these old bindings anymore. In fact, I didn’t want to use Lua at all. Lua was originally used for the level scripts, but I replaced this in favour of another language (which is no longer maintained 😒, but I’m not changing it again).

The original CCLM Editor

So far the editor boots up, but that’s about it. I can move the cursor around but I can’t add new tiles or load existing levels. There seems to be some weird things going on with the image name lookup. I originally thought image name were case insensitive, but after looking at the image name lookup logic in the game itself, I’m not so sure.

How much time I’d like to spend on this is still a bit of a question. It all depends whether I’d like to release the game itself in some fashion. There are still questions about whether I’m allowed to, given that the graphics are not my own. Still need to think about that.

But in any case, good to see the old editor again.

The level editor was actually using older SDL v1 bindings, but it was relatively easy to port them over to v2, although some gaps are still present. ↩︎
Lua was actually the second language used by the editor. The first was a Go native TCL interpretor. ↩︎

Fri, 10 Feb 2023 09:16:32 +1100

Trying out Keyboard Maestro to automate some niggly things I occasionally need to do. Got my first macro working, which converts a selected string FromCamelCase to UPPER_SNAKE_CASE.

So far I’m impressed. Looking forward to finding other things I can automate away with this.

Sun, 22 Jan 2023 13:44:04 +1100

On the subject of birds, I was looking at my status.lol statuses this morning. There are only a handful on there but I saw these two and it made me smile. I obviously posted them while I was looking after my sisters cockatiels last November.

0)' and the other saying 'Ok, parrots off hand. Back to work'">

Poking Around The Attic Of Old Coding Projects

Wed, 28 Dec 2022 16:27:00 +1100

I guess I’m in a bit of a reflective mood these pass few days because I spent the morning digging up an old project that was lying dormant for several years. It’s effectively a clone of Chips Challenge, the old strategy game that came with the Microsoft Entertainment Pack. I was a fan of the game when I was a kid, even though I didn’t get through all the levels, and I’ve tried multiple times to make a clone of it.

The earliest successful clone I can think of was back when I was using Delphi, which I think was my teens. It’s since been lost but I do recall having a version that work and was reasonably true to the original game as possible. It wasn’t a particularly accurate clone: I do recall some pretty significant bugs, and the code itself was pretty awful. But it was nice to be able to do things like design my own levels (I wasn’t as internet savvy back then and I didn’t go looking for level editors for the Microsoft’s release of Chips Challenge). Eventually I stopped working on it, and after a few updates to the family computer, plus a lack of backups or source control, there came a time where I lost it completely.

Years later, I made another attempt at building a clone. I was dabbling in .Net at the time and I think I was working on it as an excuse to learn C#. I think I got the basics of the game and associated level editor working but I didn’t get much further than that. Either I got bored and stopped working on it.

I started the latest clone nine years ago. I can’t remember the original motivation. I was just getting into Go at the time and I think it was both to learn how to build something non-trivial in the language, and to determine how good Go was for building games. Although this is probably just a rationalisation: I’m sure the real reason was to work on something fun on the side.

Screenshot of CCLM, the latest clone.

Over the first five years of its life or so, I worked on it on and off, adding new game elements (tiles, sprites, etc.) and capabilities like level scripts. One thing I am particularly proud of was building a mini-language for selecting game elements using something akin to CSS selectors. Want to select all wall tiles? Use the selector SOLD. How about configuring a water tile to only allow gliders and the player but only if they have the flipper? Set the Immune attribute of the water tile to GLID,PLYR:holding(flippers). This was particularly powerful when working on tile and sprite definitions.

A sample of how some of the tiles are defined, including usage of the selectors.

I didn’t put as much effort into content however. As of today, there are only 18 or so unique levels, and about half of them are ones that I consider good. I certainly put little effort into the graphics. Many of the tile images were just taken from the original tile-set and any additional graphics were basically inspirations from that. This blatant copyright violation is probably why this project won’t see the light of day.

The level editor, and one of the rare times when it's not crashing.

I’m impressed on how Go maintains its backwards capability: moving from 1.13 to 1.19 was just a matter of changing the version number in the .mod file. I haven’t updating any of the libraries, and I’m sure the only reason why it still builds is because I haven’t dared to try.

I’ll probably shouldn’t spend a lot of time on this. But it was fun to revisit this for a while.

One final thing: I might write more about projects I’ve long since abandoned or have worked on and haven’t released, mainly for posterity reasons but also because I like reflecting on them later. You never know what you’d wish you documented until you’ve lost the chance to do so.

Tue, 27 Dec 2022 16:15:06 +1100

Spent the day restyling the Dynamo-Browse website. The Terminal theme was fun, but over time I found the site to be difficult to navigate. And if you consider that Dynamo-Browse is not the most intuitive tool out there, an easy to navigate user manual was probably important. So I replaced that theme with Hugo-Book, which I think is a much cleaner layout. After making the change, and doing a few small style fixes, I found it to be a significant improvement.

I also tried my hand at designing a logo for Dynamo-Browse. The blue box that came with the Terminal theme was fine for a placeholder, but it felt like it was time for a proper logo now.

I wanted something which gave the indication of a tool that worked on DynamoDB tables while also leaning into it’s TUI characteristics. My first idea was a logo that looked like the DynamoDB icon in ASCII art. So after attempting to design something that looks like it in Affinity Designer, and passing it through an online tool which generated ASCII images from PNG, this was the result:

I tried adjusting the colours of final image, and doing a few things in Acorn to thicken the ASCII characters themselves, but there was no getting around the fact that the logo just didn’t look good. The ASCII characters were too thin and too much of the background was bleeding through.

So after a break, I went back to the drawing board. I remembered that there were actually Unicode block characters which could produce filled-in rectangles of various heights, and I wondered if using them would be a nice play on the DynamoDB logo. Also, since the Dynamo-Browse screen consists of three panels, with only the top one having the accent colour, I thought having a similar colour banding would make a nice reference. So I came up with this design:

And I must say, I like it. It does look a little closer to low-res pixel art than ASCII art, but what it’s trying to allude to is clear. It looks good in both light mode and dark mode, and it also makes for a nice favicon.

That’s all the updates for the moment. I didn’t get around to updating the screenshots, which are in dark-mode to blend nicely with the dark Terminal theme. They actually look okay on a light background, so I can probably hold-off on this until the UI is changed in some way.

Sun, 18 Dec 2022 13:45:29 +1100

Ok, thank you for the insistent reminders, Patreon. I know my subscription for CGP Grey is coming up for renewal. You only need to tell me once. 🤦‍♂️

Project Exploration: A Check-in App

Sun, 18 Dec 2022 09:22:40 +1100

I’m in a bit of a exploratory phase at the moment. I’ve set aside Dynamo-Browse for now and looking to start something new. Usually I need to start two or three things before I find something that grabs me: it’s very rare that I find myself something to work on that’s exciting before I actually start working on it. And even if I start something, there’s a good chance that I won’t actually finish it.

So it might seem weird that I’d write about these explorations at all. Mainly I do it for prosperity reasons: just something to record so that when look back and think “what was that idea I had?”, I have something to reflect on.

With that out of the way, I do have a few ideas that are worth considering. Yesterday, I’ve started a new Flutter project in order to explore an idea for an app that’s been rattling around in my head for about a month or two.

Basically the idea is this: I keep a very simple check-in blog where I post check-ins for locations that seem useful to recall down the line. At the moment I post these check-ins manually, and usually a few hours after I leave in order to maintain some privacy of my movements. I’ve been entertaining the idea of an app that would do this: I can post a check-in when I arrive but it won’t be published several hours after I leave. The check-ins themselves follow a consistent format so the actual act of filling in the details can be handled by the app by presenting these properties like a regular form. At the same time, I wanted to try something with the Micropub format and possibly the IndieAuth protocol.

So I started playing around with a Flutter app that could do this. I got to the point where I can post new check-ins and they will show up in a test blog. Here are some screenshots:

The home screen, which obviously needs a bit of work. Pressing the floating action button will create a new checkin.

Selecting the type of check-in.

Each type will have different properties. After selecting the check-in type, they will be presented to you in a form.

How it will ultimately look on the blog.

It’s still very early stages at this moment. For one thing, check-ins are published as soon as you press “Checkin”. Eventually they should be stored on the device and then published at a later time. The form for entering checkins should also be slightly different based on the checkin type. Restaurants and cafes should offer a field to enter a star rating, and airport checkins should provide a way to describe your route.

I’m not sure if I will pursue this any further. We’ll see how I feel. But it was good to get something up and running in a couple of hours.

Tue, 29 Nov 2022 12:58:11 +1100

Flight home from the US is next week. I’m hoping for an uneventful trip. The news is not cooperating though. 😏

Dynamo-Browse Running With iSH

Sun, 27 Nov 2022 10:15:30 +1100

Bit of a fun one today. After thinking about how one could go about setting up a small dev environment on the iPad, I remembered that I actually had iSH installed. I’ve had for a while but I’ve never really used it since I never installed tools that would be particularly useful. Thinking about what tools I could install, I was curious as to whether Dynamo-Browse could run on it. I guess if Dynamo-Browse was a simple CLI tool that does something and produces some output, it wouldn’t be to difficult to achieve this. But I don’t think I’d be exaggerating if I said Dynamo-Browse is a bit more sophisticated than your run-of-the-mill CLI tool. Part of this is finding out not only whether building it was possible, but whether it will run well.

Answering the first question involves determining which build settings to use to actually produce a binary that worked. Dynamo-Browse is a Go app, and Go has some pretty decent cross-compiling facilities so I had no doubt that such settings existed. My first thought was a Darwin ARM binary since that’s the OS and architecture of the iPad. But one of the features of iSH is that it actually converts the binary through a JIT before it runs it. And it turns out, after poking around a few of the included binaries using file, that iSH expects binaries to be ELF 32-bit Linux binaries.

Thus, setting GOOS to linux and GOARCH to 386 will produced a binary that would run in iSH:

GOOS=linux GOARCH=386 go build -o dynamo-browse-linux ./cmd/dynamo-browse/

After uploading it to the iPad using Airdrop and launching in in iSH, success!

So, is runs; but does is run well? Well, sadly no. Loading and scanning the table worked okay, but doing anything in the UI was an exercise in frustration. It takes about two seconds for the key press to be recognised and to move the selected row up or down. I’m not sure what the cause of this is but I suspect it’s the screen redrawing logic. There’s a lot of string manipulation involved which is not the most memory efficient. I’m wondering if building the app using TinyGo would improve things.

But even so, I’m reasonably impress that this worked at all. Whether it will mean that I’ll be using iSH more often for random tools I build remains to be seen, but at least the possibility is there.

Update: While watching a re:Invent session on how a company moved from Intel to ARM, they mentioned a massive hit to performance around a function that calculates the rune length of a Unicode character. This is something that this application is constantly doing in order to layout the elements on the screen. So I’m wondering if this utility function could be the cause of the slowdown.

Update 2: Ok, after thinking about this more, I think the last update makes no sense. For one thing, the binary iSH is running is an Intel one, and although iSH is interpreting it, I can’t imagine the slowdowns here are a result of the compiled binary. For another, both Intel and ARM (M1) builds of Dynamo-Browse work perfectly well on desktops and laptops (at least on MacOS systems). So the reason for the slowdown must be something else.

Thu, 10 Nov 2022 13:07:36 +1100

Google Photos came up with this amusing suggestion today.

Just to be clear: it was the birds that were rotated, not the camera. 😀

Audax Toolset Version 0.1.0

Sat, 22 Oct 2022 11:20:36 +1100

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 😛. ↩︎

Sun, 09 Oct 2022 10:27:29 +1100

Working on recording that how-to video again this morning. Managed to get a take that I’m happy with. This is after maybe 35 recordings in total which didn’t work (wow, video is not easy). Now downloading the trial version of Final Cut Pro to try and edit the thing.

Overlay Composition Using Bubble Tea

Sat, 24 Sep 2022 14:58:24 +1100

Working on a new feature for Dynamo-Browse which will allow the user to modify the columns of the table: move them around, sort them, hide them, etc. I want the feature to be interactive instead of a whole lot of command incantations that are tedious to write. I also kind of want the table whose columns are being manipulated to be visible, just so that the affects of the change would be apparent to the user while they make them.

This is also an excuse to try something out using Bubble Tea — the TUI framework I’m using — which is to add the ability to display overlays. These are UI elements (the overlay) that appear above other UI elements (the background). The two are composed into a single view such that it looks like the overlay is obscuring parts of the background, similar to how windows work in MacOS.

Bubble Tea doesn’t have anything like this built in, and the way views are rendered in Bubble Tea doesn’t make this super easy. The best way to describe how views work is to think of them as “scanlines.” Each view produces a string with ANSI escape sequences to adjust the style. The string can contain newlines which can be used to move the cursor down while rendering. Thus, there’s no easy way position the cursor at an arbitrary position and render characters over the screen.¹

So, I thought I’d tackle this myself.

Attempt 1

On the surface, the logic for this is simple. I’ll render the background layer up to the top most point of the overlay. Then for each scan line within the top and bottom border of the overlay, I’ll render the background up to the overlay’s left border, then the contents of the overlay itself, then the rest of the background from the right border of the overlay.

My first attempt was something like this:

line := backgroundScanner.Text()
if row >= c.overlayY && row < c.overlayY+c.overlayH {
    // When scan line is within top & bottom of overlay
    compositeOutput.WriteString(line[:c.foreX])
    
    foregroundScanPos := row - c.overlayY
    if foregroundScanPos < len(foregroundViewLines) {
        displayLine := foregroundViewLines[foregroundScanPos]
        compositeOutput.WriteString(lipgloss.PlaceHorizontal(
            c.overlayW,
            lipgloss.Left,
            displayLine,
            lipgloss.WithWhitespaceChars(" ")),
        )
    }
    
    compositeOutput.WriteString(line[c.overlayX+c.overlayW:])
} else {
    // Scan line is beyond overlay boundaries of overlay
    compositeOutput.WriteString(line)
}

Here’s how that looked:

Yeah, not great.

Turns out I forgot two fundamental things. One is that the indices of Go strings works on the underlying byte array, not runes. This means that attempting to slice a string between multi-byte Unicode runes would produce junk. It’s a little difficult to find this in the Go Language Guide apart from this cryptic line:

A string’s bytes can be accessed by integer indices 0 through len(s)-1

But it’s relatively easy to test within the Go playground:

package main

import "fmt"

func main() {
    fmt.Println("世界😀😚🙃😇🥸😎"[1:6])                   // ��界
    fmt.Println(string([]rune("世界😀😚🙃😇🥸😎")[1:6]))   // 界😀😚🙃😇
}

The second issue is that I’m splitting half-way through an ANSI escape sequence. I don’t know how long the escape sequence is to style the header of the item view, but I’m betting that it’s longer than 5 bytes (the overlay is to be position at column 5). That would explain why there’s nothing showing up to the left of the overlay for most rows, and why the sequence 6;48;5;188m is there.

Attempt 2

I need to modify the logic so that zero-length escape sequences are preserved. Fortunately, one of Bubble Tea’s dependency is reflow, which offers a bunch of nice utilities for dealing with ANSI escape sequences. The function that looks promising is truncate.String, which will truncate a string at a given width.

So changing the logic slightly, the solution became this:

// When scan line is within top & bottom of overlay
compositeOutput.WriteString(truncate.String(line, uint(c.overlayX)))

foregroundScanPos := r - c.overlayY
if foregroundScanPos < len(foregroundViewLines) {
    displayLine := foregroundViewLines[foregroundScanPos]
    compositeOutput.WriteString(lipgloss.PlaceHorizontal(
        c.overlayW,
        lipgloss.Left,
        displayLine,
        lipgloss.WithWhitespaceChars(" "),
    ))
}

rightStr := truncate.String(line, uint(c.foreX+c.overlayW))
compositeOutput.WriteString(line[len(rightStr):])

The results are a little better. At least the left side of the overlay looked OK now:

But there are still problems here. Notice the [0m at the right side of the overlay on the selected row. I can assure you that’s not part of the partition key; take a look at the item view to see for yourself. And while you’re there, notice the header of the item view? That should be a solid grey bar, but instead it’s cut off at the overlay.

I suspect that rightStr does not have the proper ANSI escape sequences. I’ll admit that the calculation used to set rightStr is a bit of a hack. I’ll need to replace it with a proper way to detect the boundary of an ANSI escape sequence. But it’s more than just that. If an ANSI escape sequence starts off at the left side of the string, and continues on “underneath” the overlay, it should be preserved on the right side of the overlay as well. The styling of the selected row and the item view headers are examples of that.

Attempt 3

So here’s what I’m considering: we “render” the background underneath the overlay to a null buffer while recording any escape sequences that were previously set on the left, or were changed underneath the overlay. We also keep track of the number of visible characters that were seen. Once the scan line position reached the right border of the overlay, we replay all the ANSI escape sequences in the order that were found, and then render the right hand side of the scan line from the first visible character.

I was originally considering rendering these characters to a null reader, but what I actually did was simply count the length of visible characters in a loop. The function to do this looks like this:

func (c *Compositor) renderBackgroundUpTo(line string, x int) string {
    ansiSequences := new(strings.Builder)
    posX := 0
    inAnsi := false

    for i, c := range line {
        if c == ansi.Marker {
            ansiSequences.WriteRune(c)
            inAnsi = true
        } else if inAnsi {
            ansiSequences.WriteRune(c)
            if ansi.IsTerminator(c) {
                inAnsi = false
            }
        } else {
            if posX >= x {
                return ansiSequences.String() + line[i:]
            }
            posX += runewidth.RuneWidth(c)
        }
    }
    return ""
}

And the value set to rightStr is changed to simply used this function:

rightStr := c.renderBackgroundUpTo(line, c.foreX+c.overlayW)

Here is the result:

That looks a lot better. Gone are the artefacts from splitting in ANSI escape sequences, and the styling of the selected row and item view header are back.

I can probably work with this. I’m hoping to use this to provide a way to customise the columns with the table view. It’s most likely going to power other UI elements as well.

Well, there might be a way using ANSI escape sequences, but that goes against the approach of the framework. ↩︎

Tue, 20 Sep 2022 10:05:42 +1100

🎉

Intermediary Representation In Dynamo-Browse Expressions

Fri, 16 Sep 2022 23:37:20 +1100

One other thing I did in Dynamo-Browse is change how the query AST produced the actual DynamoDB call.

Previously, the AST produced the DynamoDB call directly. For example, if we were to use the expression pk = "something" and sk ^= "prefix", the generated AST may look something like the following:

The AST will then be traversed to determine whether this could be handled by either running a query or a scan. This is called “planning” and the results of this will determine which DynamoDB API endpoint will be called to produce the result. This expression may produce a call to DynamoDB that would look like this:

client.Query(&dynamodb.QueryInput{
    TableName: "my-table-name",
    KeyConditionExpression: "#0 = :0 and beings_with(#1, :1)",
    ExpressionAttributeNames: map[string]string{
        "#0": "pk",
        "#1": "sk",
    },
    ExpressionAttributeValues: map[string]types.AttributeValue{
         ":0": &types.StringAttributeValue{ Value: "something" },
         ":1": &types.StringAttributeValue{ Value: "prefix" },
    },
})

Now, instead of determining the various calls to DynamoDB itself, the AST will generate an intermediary representation, something similar to the following:

The planning traversal will now happen off this tree, much like it did over the AST.

For such a simple expression, the benefits of this extra step may not be so obvious. But there are some major advantages that I can see from doing this.

First, it simplifies the planning logic quite substantially. If you compare the first tree with the second, notice how the nodes below the “and” node are both of type “binOp”. This type of node represents a binary operation, which can either be = or ^=, plus all the other binary operators that may come along. Because so many operators are represented by this single node type, the logic of determining whether this part of the expression can be represented as a query will need to look something like the following:

First determine whether the operation is either = or ^= (or whatever else)
If it’s = and the field on the left is either a partition or sort key, this can be represented as a query
If it’s ^=, first determine whether the operand is a string, (if not, fail) and then determine whether the field on the left is a sort key. If so, then this can be query.
Otherwise, it will have to be a scan.

This is mixing various stages of the compilation phase in a single traversal: determining what the operator is, determining whether the operands are valid (^= must have a string operand), and working out how we can run this as a query, if at all. You can imagine the code to do this being large and fiddly.

With the IR tree, the logic can be much simpler. The work surrounding the operand is done when the AST tree is traverse. This is trivial: if it’s = then produce a “fieldEq”; if it’s ^= then produce a “fieldBeginsWith”, and so on. Once we have the IR tree, we know that when we encounter a “fieldEq” node, this attribute can be represented as a query if the field name is either the partition or sort key. And when we encounter the “fieldBeginsWith” node, we know we can use a query if the field name is the sort key.

Second, it allows the AST to be richer and not tied to how the actual call is planned out. You won’t find the ^= operator in any of the expressions DynamoDB supports: this was added to Dynamo-Browse’s expression language to make it easier to write. But if we were to add the “official” function for this as well — begins_with() — and we weren’t using the IR, we would need to have the planning logic for this in two places. With an IR, we can simply have both operations produce a “fieldBeginsWith” node. Yes, there could be more code encapsulated by this IR node (there’s actually less) but it’s being leverage by two separate parts of the AST.

And since expressions are not directly mappable to DynamoDB expression types, we can theoretically do things like add arithmetic operations or a nice suite of utility functions. Provided that these produce a single result, these parts of the expression can be evaluated while the IR is being built, and the literal value returned that can be used directly.

It felt like a few other things went right with this decision. I was expecting this to take a few days, but I was actually able to get it built in a single evening. I’m also happy about how maintainable the code turned out to be. Although there are two separate tree-like types that need to be managed, both have logic which is much simpler than what we were dealing with before.

All in all, I’m quite happy with this decision.

Tue, 13 Sep 2022 08:50:07 +1100

Saw someone at work use Numi to show some maths so I’m giving it a try. Only just started using it but I already like it. Feels very similar to Tot and Boop: a small MacOS utility that fits nicely in that middle-ground between Calculator and a spreadsheet.

Sat, 03 Sep 2022 12:24:47 +1100

It could be that I’m just an old fogie that doesn’t like whimsy, but chalk me up as someone who doesn’t like the wiggling seek bar in Android’s playback notification.

Wed, 31 Aug 2022 12:15:29 +1100

You can tell I’m bored at work when I spend time building stupid little utilities for myself instead of actually doing the task I should be doing. Today’s stupid little utility: a TUI tool to list merge requests I’ve posted for review. Saves a trip to the browser.

Fri, 26 Aug 2022 13:55:23 +1100

Those “Accept Yours” & “Accept Theirs” buttons in GoLand’s conflicts dialog are a bit of a tease. Might be that I’m missing something (which is possible) but I though a file appearing here means that I manually need to review it. Would anyone blindly accept changes like this?

Mon, 25 Jul 2022 08:06:00 +1100

I’ve been seeing this message an awful lot recently when I’m trying to use mobile data. I originally thought it was Telstra, but now I suspect it’s Android, as restarting the phone seemed to have fixed it.

Tue, 07 Jun 2022 22:30:39 +1100

The names for GitHub Codespaces are randomly generated, but I kinda like the one chosen for this website repo. Seems fitting in a way.

WWDC Videos In Broadtail

Mon, 16 May 2022 21:20:00 +1100

Some more work on Broadtail. This time, I added the ability to use it to download Apple WWDC videos.

The way it works is based on the existing RSS feed concept. In order to get the list of videos for a particular WWDC year, you “subscribe” to that by setting up a feed with the new “Apple Developer Videos” type. The external ID is taken from the URL slug of the web-site that Apple publishes the session videos. For example, for WWDC 2021, the external ID would be “wwdc2021”.

Downloading the videos is more or less the same.

There are a few differences between this feed type, and the YouTube RSS feed. For instance, it only makes use of what is available from the website, which means details like publishing date or duration are not really available. This is why the “Publishing” date is displayed as “unknown”. That’s also why the videos are arranged in alphabetical order and the feed itself is not automatically refreshed (although doing so manually by clicking “Refresh” within the feed page will work). These are actually properties that can now be applied to all feeds of one wishes, although the YouTube feeds are still arranged in reverse chronological order by default.

From a coding perspective, this involved a lot of refactoring. I was hoping to move to a more generic feed and video type, but this was the feature that eventually got me to do so. Thing is that if I wanted to add more feed and video types in the future, it should be easier to do so.

Feed Rules In Broadtail

Mon, 09 May 2022 21:17:00 +1100

Generally, when there’s a video that I’m interesting in watching, I take a look at Broadtail to see if it’s available. When it is, I go ahead and download it.

However, some videos take a long time to download — we’re talking 10 hours or so — and they’re usually published when I’m not looking, like during the night when I’m asleep (thank’s time-zones). So I’d thought it would be nice for Broadtail to kick off the download for me when the video shows up in the feed.

So I’ve added Feed Rules to do this.

Feed rules are very simple automations that happen when new items are found in during the RSS feed poll. When the video shows up in the feed, and matches the rule condition, Broadtail will perform the rule action for that video.

Feed Rules are added as a new sub-section in “Settings”, which itself is a new top-level section of the app (the “General” sub-section is empty at this stage).

Feed Rules consist of a name, whether the rule is active, a set of conditions, and a set of action. A feed item will need to match all the conditions of the rule in order for the actions to be performed.

The conditions of a feed rule touch upon the following properties of a feed item:

The feed in which it appears in. This can be set to “any” to apply the rule to all feed items.
Whether the title matches a given string. The match rules are similar to the searches in the feed item list views, which are appearance of each of the space separated tokens somewhere in the title (in any case) with phrases appearing as quoted strings.
Whether the description matches a given string.

If a feed item matches all the conditions, Broadtail can perform the following actions for the feed item:

Start a download of the video
Mark the feed item as a favourite

There might be more conditions or actions added in the future. So far this seems to be the bare minimum to make the feature usable.

Sat, 23 Apr 2022 10:25:00 +1100

Oh, I hope not.

New AWS Tools Commands

Fri, 25 Mar 2022 21:05:00 +1100

For a while now, I’ve been wanting some tools which would help manage AWS resources that would also run in the terminal. I know in most circumstances the AWS console would work, but I know for myself, there’s a lot of benefit from doing this sort of administration from the command line.

I use the terminal a lot when I’m developing or investigating something. Much of the time while I’m in the weeds I’ve got a bunch of tabs with tools running and producing output, and I’m switching between them as I try to get something working across a bunch of systems.

This is in addition to cases when I need to manage an AWS mock running on the local machine. The AWS console will not work then.

At the start of the week, I was thinking of at least the following three tools that I would like to see exist:

A TUI browser/workspace for DynamoDB tables
A TUI workspace for monitoring SQS queues
Some tool for reading JSON style log files.

As of yesterday, I actually got around to building the first two.

The first is a tool for browsing DynamoDB tables, which I’m calling dynamo-browse (yes, the names are not great). This tool does a scan of a DynamoDB table, and shows the resulting items in a table. Each item can be inspected in full in the lower half of the window by moving the selection.

At the moment this tool only does a simple scan, and some very lightweight editing of items (duplicate and delete). But already it’s proven useful with the task I was working on, especially when I came to viewing the contents of test DynamoDB instances running on the local machine.

The second tool is used for monitoring SQS queues.

This will poll for SQS messages from a queue and display them in the table here. The message itself will be pretty printed in the lower half of the screen. Messages can also be pushed to another queue. That’s pretty much it so far.

There are a bunch of things I’d like to do in these tools. Here’s a list of them:

Queries in DynamoDB: There’s currently no way to run queries or filter the resulting items. I’m hoping to design a small query language to do this. I’m already using Participal to power a very simple expression language to duplicate items, so as long as I can design something that is expressive enough and knows how to use particular indices, I think this should work.
Putting brand new items in DynamoDB: At the moment you can create new items based on existing items in a way, but there’s currently no way to create brand new items or adjust the attributes of existing items. For this, I’d like to see an “edit item” mode, where you can select the attribute and edit the value, change the type, add or remove attributes, etc. This would require some UI rework, which is already a bit tentative at this stage (it was sort of rushed together, and although some architectural changes have been made to the M and the C in MVC, work on the V is still outstanding).
Preview item changes before putting them to DynamoDB: This sort of extends the point above, where you see the diff between the old item and new item before it’s put into DynamoDB.
Workspaces in SQS Browse: One idea I have for SQS browse is the notion of “workspace”. This is a persistent storage area located on the disk where all the messages from the queue would be saved to. Because SQS browse is currently pulling messages from the SQS queue, I don’t want the user to get into a state where they’ve lost their messages for good. The idea is that a workspace is always created when SQS browse is launch. The user can choose the workspace file explicitly, but if they don’t, then the workspace will be created in the temp directory. Also implicit in this is support for opening existing workspaces to continue work in them.
Multiple queues in SQS Browse: Something that I’d like to see in SQS Browse is the ability to deal with multiple queues. Say you’re pulling from one queue and you’d like to push it to another. You can use a command to add a queue to the workspace. Then, you can do things like poll the queue, push messages in the workspace to the queue, monitor it’s queue length, etc. Queues would be addressable by number or some other way, so you can simply run the command push 2 to push the current message to queue 2.

As for when I’ll actively work on these tools. It will probably be when I need to use them. But in the short term, I’m glad I got the opportunity to start working on them. They’ve already proven quite useful to me.

Fri, 11 Mar 2022 08:19:34 +1100

This is by far the most useful quick action I’ve made in Automator. It generates a UUID, and places it in the pasteboard. I’ve got it bound to Ctrl+Opt+Cmd+U and I’ve been using it constantly over the last week (writing a lot of tests with test data).

Some More Updates of Broadtail

Sat, 05 Mar 2022 20:49:00 +1100

I’ve made some more changes to Broadtail over the last couple of weeks.

The home page now shows a list of recently published videos below the currently running jobs.

Clicking through to “Show All” displays all the published videos. A simple filter can be applied to filter them down to videos with titles containing the keywords (note: nothing fancy with the filter, just tokenisation and an OR query).

Finally, items can now be favourited. This can be used to select videos that you may want to download in the future. I personally use this to keep the list of “new videos” in the Plex server these videos go to to a minimum.

Feeds In Broadtail

Sat, 06 Nov 2021 21:32:00 +1100

My quest to watch YouTube without using YouTube got a little closer recently with the addition of feeds in Broadtail. This uses the YouTube RSS feed endpoint to list videos recently added to a channel or playlist.

There are a bunch of channels that I watch regularly but I’m very hesitant to subscribe to them within YouTube itself (sorry YouTubers, but I choose not to smash that bell icon). I’m generally quite hesitant to give any signal to YouTube about my watching habits, feeding their machine learning models even more information about myself. But I do want to know when new videos are available, so that I can get them into Plex once they’re released. There is where feeds come in handy.

Also improved is the display of video metadata when selecting a feed item or entering a video ID in the quick look bar. Previously this would immediately start a download of the video, but I prefer knowing more about the video first. These downloads aren’t free, and they usually take many hours to get. Better to know more about them before committing to it.

Incidentally, I think this mode of watching has a slight benefit. There are days when I spend the whole evening binging YouTube, not so much following the algorithm but looking at the various channels I’m interested in for videos that I haven’t seen yet. Waiting several hours for a video download feels a little more measured, and less likely to send me down the YouTube rabbit hole. I’m sure there will still be evenings when I do nothing else other than watch TV, but hopefully that’s more of a choice rather than an accident.

I think this is enough on Broadtail for the time being. It’s more or less functional for what I want to do with it. Time to move onto something else.

Some Screenshots Of Broadtail

Sun, 31 Oct 2021 13:09:00 +1100

I spent some time this morning doing some styling work on Broadtail, my silly little YouTube video download manager I’m working on.

Now, I think it’s fair to say that I’m not a designer. And these designs look a little dated, but, surprisingly, this is sort of the design I’m going for: centered pages, borders, etc. A bit of a retro, tasteless style that may be ugly, but still usable(-ish).

It’s not quite finished — the colours need a bit of work — but it’s sort of the style I have in my head.

Sun, 24 Oct 2021 11:46:14 +1100

On a bit of a writing streak: 50 consecutive days of at least one blog post or journal entry.

P.S. I wonder if writing an entry about this streak, just to keep the streak going, is a form of cheating.

Thu, 21 Oct 2021 16:28:00 +1100

Oh the irony. First weekend after Lockdown 6 and with plans for activities outdoors…

Tue, 05 Oct 2021 07:36:20 +1100

One week to go! 💉💉

Fri, 09 Jul 2021 12:39:59 +1100

Trying my hand at logo design for something I’m working on. I’m aiming for something that looks like a mix between a bookmark, the letter D, and something to suggest synchronising stuff. This is probably the best I’ve got so far.

Wed, 23 Sep 2020 09:14:46 +1100

Ah, Day One. At least let me get through the day first.