Blog Posts

Taking Rich Screenshots with Wezterm

When working on this site, I’ve often wanted to include a screenshot or two. But since git doesn’t work well with binary files and I don’t want to have to deal with media hosting I’ve tended to shy away from it.

However, a lot of what I want to take a screenshot of can be rendered in a terminal.

Which is suddenly quite interesting as a terminal’s contents can be entirely described in plain(-ish) text. Surely it must be possible to capture the contents of a terminal window and then render it as some kind of image? Perhaps an SVG?

M-x pdb |*gud-test*        x                                 [37%] 15:41 21/06/25 ☰ -> if not state.headers_complete:                                           (Pdb)  > /var/home/alex/Projects/swyddfa/lsp-devtools/develop/lib/lsp-devtools/ls\ p_devtools/agent/server.py(166)feed()                                       -> if (idx := state.buffer.find(SEP)) == -1:                                (Pdb)  > /var/home/alex/Projects/swyddfa/lsp-devtools/develop/lib/lsp-devtools/ls\ p_devtools/agent/server.py(169)feed()                                       -> line, state.buffer = state.buffer[:idx], state.buffer[idx + len(SEP) :]  (Pdb) idx 30                                                                          (Pdb)  -  *gud-test* 25:6      (Debugger:run Apheleia)                             +  158 # messages to be stuck in the buffer... +  159 # +  160 # So we will keep running that parser as long as the buffe\ r continues toshrink +  161 previous_length = len(state.buffer) + 1                     +  162 whilelen(state.buffer) < previous_length:                  +  163 previous_length = len(state.buffer)                     +  164 breakpoint()                                            +  165 ifnot state.headers_complete:                          +  166 if (idx := state.buffer.find(SEP)) == -1:           +  167 return +  168  + =>169 line, state.buffer = state.buffer[:idx], state.buf\ -🖿 lsp-devtools server.py 169:0      (Python Flymake[001] ws Apheleia© 

Yes it is!

In this blog post I describe how I arrived at the workflow I used to include the above screenshot on this website.

Blogging with Sphinx and denote.el

If you have spent any time following the Emacs community, you will have likely come across the denote.el project. denote.el defines a clever file-naming scheme and provides an associated Emacs package containing utilities for managing files which follow this naming scheme.

In this blog post I outline how I have adopted denote.el to manage the content on this site and how I’ve extended Sphinx to take advantage this.

Intstalling Emacs with systemd-sysext

One issue with building Emacs from source, or more specifically my hack to ensure that the required system libraries are available on Aurora, is that in some situations the system version of Emacs “wins”.

For example, I wanted to experiment with running the Emacs daemon through systemd:

$ systemctl --user start emacs

Which failed to load my config correctly. It was only after a closer look did I realise that despite specifying the --user flag, systemd was defaulting to the emacs.service file provided by the system emacs package in /usr/... and was therefore running Emacs v29 and not my v30 build.

But then I stumbled across systemd-sysext

TIL: Debugging go programs with gdb

 
$ gdb --args podman info
(gdb) run
Starting program: /usr/bin/podman info
[Thread debugging using libthread_db enabled]
...
WARN[0000] Found incomplete layer "6748b9a4e6f2d75763acd0d8351dfb92d4281a0b3546cc68042fb8cb5e1b7c3c", deleting it

Thread 9 "podman" received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7fbacbfff6c0 (LWP 10496)]
Downloading source file /usr/src/debug/podman-5.3.1-1.fc41.x86_64/vendor/github.com/containers/storage/layers.go
github.com/containers/storage.(*layerStore).load (r=0xc00024c140, lockedForWriting=true, ~r0=<optimized out>, ~r0=<optimized out>, ~r1=..., ~r1=...) at /usr/src/debug/podman-5.3.1-1.fc41.x86_64/vendor/github.com/containers/storage/layers.go:917
917                     if layer.Flags == nil {

<Freeze frame, record scratch>

You might be wondering how I got here…

And no, I wasn’t trying to work on podman!

TIL: Inspecting Python Threads

One of my favourite things about Python is that pretty much everything about the language can be inspected at runtime and today I found out this is true even for threads.

While working on this PR I kept running into issues where the esbonio process would not terminate, despite everything to my knowledge at least, was being shutdown as expected. Having encountered issues like this before, I knew the culprit was likely to be some background thread was stuck on something and keeping the process alive. The problem was I had no idea which thread it could be or what it was doing.

Nix: Day to Day Usage

This blog post marks a change in my usage of Nix, I’m (just!) past the point of trying to get something to work and now starting to incorporate it into some of my regular workflows. So instead of trying to accomplish some major task, this post is a small collection of things I’ve learned over the past few weeks.

Integrating Esbonio with Neovim Using Nix

So far I’ve been learning how to use Nix by trying to package and define development shells for esbonio (see here if you are interested). While useful, the end result is not too dissimilar to what you can get with standard Python tooling. Indeed, the main reason I started looking into Nix was the promise of it being able to manage more than just Python libraries.

Since esbonio is a language server, it would be useful for Nix to create standardised environments where the language server is pre-configured for a given editor - great for debugging and demos!

In this blog post I try to define an environment in which Neovim is installed and configured to use the esbonio language server for reStructuredText files.

My Next Steps with Nix: Overlays

Last time, I experimented with writing a flake that defined development environments for the esbonio package spanning multiple Python versions. During that process I also packaged pytest-lsp using an ad-hoc nix expression as part of the esbonio repo.

In this post I look into writing a similar flake for the pytest-lsp package itself, but this time using overlays to override and extend the nixpkgs package set.

If you are interested, you can find the final version of the code here.

My First Steps with Nix

Nix, depending on the context, can refer to a programming language, a package manager or a Linux Distro.

Personally, I’m most insterested in the package manager aspect and the promise of it being able to create declarative, reproducable development environments. With a configuration file and the nix develop command you can activate a kind of “virtual environment” that contains not just your Python packages - but any program defined by the configuration!

I find that idea particuarly exciting when working on a language server like esbonio, since it needs to be able to work against a variety of Python versions, Sphinx versions, as well as various code editors and all their versions! Having the ability to define a particular configuration and have some tool automatically recreate it would be amazing.

But I’m getting ahead of myself, let’s see if I can get to a point where I can easily test esbonio against a range of Python versions.

Bringing Esbonio to the Browser

For the past year or so I’ve been working on a language server called Esbonio. It’s a language server designed to streamline the process of working with your Sphinx documentation projects. Currently its feature set is quite limited, but I think it does a good job of providing you with completion suggestions for all your roles, directives and cross-references.

https://github.com/swyddfa/esbonio/raw/develop/resources/images/completion-demo.gif

Anyway with the recent releases of github.dev and vscode.dev I really want to see if I can bring Esbonio into the browser version of VSCode. There’s only one problem… Esbonio is written in Python! 😬

Creating a CPython Extension

Previously, as part of my exploration into how programming languages are implemented, I wrote a very simple AST evaluator that knew how to add and multiply floats together. Since constructing these ASTs by hand is quite painful I thought it would be fun to come up with a frontend to my “programming language” which could do it for me.

Now your typical frontend would be some kind of parser built into the compiler/interpreter. However, while I’m definitely interested in parsing I don’t quite feel like tackling that just yet. Instead I’m going to have Python be the frontend and embed my toy language into it via a CPython Extension

Evaluating a Simple Abstract Syntax Tree

Programming languages and their implementation is a topic I’ve been interested in for a long time and I thought it would be worth trying to get a bit more hands on and play with some of the ideas in this space. Choosing a topic somewhat at random I’ve chosen to take a look at implementing an Abstract Syntax Tree (AST).

Saying ‘Hello, World!’ with TinyGo and WebAssembly

WebAssembly is something I’ve wanted to play with for quite a while now and I’ve finally got around to taking a look at it. In this post I describe how I managed to use TinyGo to compile a “Hello, World!” Go program into WebAssembly and execute it in the browser. So that I have something to refer back to I also describe setting up my development environment as a container using LXD.

Learning Vulkan: Enumerating Physical Devices

Being an API for talking to GPUs and other compute devices every Vulkan program starts off by looking for an appropriate physical device to use. In this post I write a little C program that initialises the Vulkan API and lists out the available devices in the system.

$ vkdevice
Device Name:            Intel(R) HD Graphics 520 (Skylake GT2)
  Type:                 Integrated GPU
  Vendor ID:            32902
  Device ID:            6422
  API Version:          v1.1.102
  Driver Version:       v19.3.1

Learning Vulkan: Overview

I have always been interested in graphics and have on numerous occasions tried to dip my toe into the world of OpenGL and more recently Vulkan. However I have never been able to get past the “Hello, World” of these technologies - drawing a triangle on screen, I think mostly becuase I never really had a goal in mind once I got that far…

But that’s (hopefully) about to change! What better excuse than a new decade to jump back into this world for the 100th time and try to get to all those interesting ideas I see people playing with all the time!

Implementing Click & Drag with Vanilla JS

Try clicking and dragging on this circle.

Disclaimer

This post makes use of a number of interactive elements to help illustrate a few concepts. Unfortunately these do not yet work on mobile devices - sorry mobile users!

I have for quite some time now wanted to play around with web development some more, particularly using web technologies to build user interfaces of some kind. However there is just so much out there it’s been impossible for me to really get anywhere past a “Hello, World!” tutorial before I find myself trying out the next new shiny.

So I’ve decided to abandon everything and try a bottom up approach where I see how far I can push the core web technologies - HTML, CSS and JavaScript. Hopefully then by the time I start using one of the gazillion libraries out there I will have a better understanding of why I needed it in the first place.

In this post I will be looking at implementing clicking and dragging functionality using only vanilla JavaScript. Clicking and dragging as a concept can apply to many kinds of interactions so in this instance I’m specifically referring to clicking on an SVG element moving it around on the page as illustrated by the demo above.

Introducing Stylo Doodles!

A few weeks back at PyConUK I gave my first lighting talk at a conference. During that talk I spoke publically about stylo for the first time. Stylo is a Python library that I have been working on for just over a year and a half and it aims to make the creation of images easier by bringing together ideas from programming and mathematics.

Version 0.6.0 was recently released which included the first feature that wasn’t written by me! It’s very exciting not only to see other people starting to take an interest in the project but taking the time to make a contribution!

Now that stylo seems to be getting to the point that it might me useful to other people wouldn’t it be great if there was a community driven example gallery that people could get inspired by? - Well now there is! And it’s called Stylo Doodles

../_images/stylo-doodles.png

I’ve Started a Blog… Again!

Not that you would have known it, but I’ve had a blog since 2014. Well 2015 if you’re feeling generous, the first (and only) post went up in the last few hours of New Year’s Eve. It was a look back on some of the projects I had worked on that year and I announced my intentions to start blogging.

Fast forward nearly 4 years and here I am announcing my intentions to start blogging - again. So I guess you are wondering what happened?

I got lost.

My first attempt at running a blog was using Jekyll and for some mystical reason (It’s been so long I can’t actually remember why), I decided that it was not the static site generator I was looking for. So I promptly set off on a voyage of discovery in search of the ultimate static site generator.