rob.rho.org.uk

Out on a Limb

2026-04-25T00:00:00+00:00

Reading OpenAI’s recent announcement of GPT 5.5, I was struck by the following pull-quote:

One engineer at NVIDIA who had early access to the model went as far as to say: “Losing access to GPT‑5.5 feels like I’ve had a limb amputated.”

They presumably intended this to be taken as an endorsement, but I read it as a warning. I don’t want to come to rely on a tool from a single vendor to such an extent that I can’t work without it. As demonstrated recently by OpenAI’s competitor Anthropic, that vendor can unilaterally degrade the service, by accident or design, or perhaps jack up the price by five times. Given the staggering expense in serving increasingly complicated models in increasingly complicated ways, both of these seem less like if then when.

A similar criticism could be levelled at cloud providers like AWS, and many other things, and it’s always wise to approach any such entanglement with eyes open. However, AI seems like a special case, as the alternative that it’s foreclosing is not another vendor, but your own skills. Despite the myriad problems with and around LLM-based coding tools, there definitely seems to be something useful there. Leaning on them too much, though, seems like a recipe for ending up in a very uncomfortable place when the music stops.

All Quiet

2026-04-05T00:00:00+00:00

It’s been a bit quiet here of late; I’ve not put anything up anything since my now-annual New Year’s Eve book post. At time of writing, that’s ninety-five days ago, which is the longest gap I’ve had since 2022 into 2023. The reason is prosaic — there’s been a lot going on both at work and at home, and I’ve simply not been able to carve out the time. I don’t plan to go into either on here, but I wanted to plant a flag in the ground to encourage me to get back to writing. I have a couple of pieces in mind, so hopefully this declaration will act as additional motivation to get them over the line.

Books of 2025

2025-12-31T00:00:00+00:00

In the same way that two points make a line, I’m going to say that two posts make a tradition. This time last year I wrote about the books I read in 2024, and suggested it might become an annual thing. Making good on that threat, here’s my reading in 2025:

(The yellow bars indicate when I started and finished each book; the open ones are for books I was reading when the year started, or still have on the go.)

The biggest through-line has been the Matha Well’s MurderBot Diaries (highlighted in green). I added these to my list about the same time as last year’s favourite Hild, but I only got around to starting at the beginning of the year¹. Once I had started, I devoured them at a breakneck pace, having to make a conscious effort to read other stuff in between to avoid running out too quickly.

They’re for the most part short (novellas rather than novels), and the style is a fantastically readable inner monologue. What really makes the series, though, is the combination of kinetic set pieces with emotional literacy and an engaging main character. If you’ve not tried them out yet, I definitely recommend that you do so. Don’t let the title put you off; it sounds like it’s about a murderous robot, but they’re actually more of a cyborg.

When I wasn’t reading about everyone’s favourite telenovela-loving Security Unit, I tried to hit a reasonable mix of fiction and non-fiction, with variety within each. Careless People, Apple in China and This is for Everyone were all interesting both in their own right and in the context of the public discussion they sparked; I’m usually late to such things, but I’m glad I pulled my finger out in these cases, and will look to do so in the future. I also revisited old classics and familiar authors, and spent some enjoyable and thought-provoking hours with vintage computer texts.

Looking back, I’m happy that the time I spent reading over the last twelve months was time well spent, and it also provides me with a prompt to think about next year. Maybe more history? Some new fiction authors, maybe new genres? In any case, now that I’ve established a tradition, I’ll share all next December.

Happy New Year.

For reference, here’s a full list of the 38 books I read in 2025:

Various: Take Us to a Better Place
Douglas Adams: The Hitchhiker's Guide to the Galaxy
Naomi Alderman: The Future
Isaac Asimov: I, Robot
Tim Berners-Lee: This Is For Everyone
Alan Blackwell: Moral Codes: Designing Alternatives to AI
Leo Brodie: Thinking FORTH
Clayton M. Christensen: The Innovator's Dilemma
Lindsey Davis: The Silver Pigs
Claire Dederer: Monsters: What Do We Do with Great Art by Bad People?
Richard deGrandis-Harrison: FORTH on the BBC Microcomputer
F. Scott Fitzgerald: The Great Gatsby
William Gibson: All Tomorrow's Parties
Nicola Griffith: The Blue Place
Kazuo Ishiguru: The Unconsoled
Beth Lincoln: The Swifts (I don't usually record books I'm reading with the girls, but this one is so good I'm making an exception. )
Jeph Loeb, Tim Sale, Bjarne Hansen: Superman For All Seasons
Tim Marshall: Prisoners of Geography
Scott McCloud: Understanding Comics: The Invisible Art
Patrick McGee: Apple in China
John Muir: My First Summer in the Sierra
Haruki Murakami: What I Talk About When I Talk About Running , 1Q84
Arthur Norman and Gillian Cattell: LISP on the BBC Microcomputer
Lewis Packwood: Curious Video Game Machines
Terry Pratchett: The Wee Free Men
Martha Wells: All Systems Red , Artificial Condition , Rogue Protocol , Exit Strategy , Network Effect , Compulsory , Home: Habitat, Range, Niche, Territory , Fugitive Telemtry , System Collapse , Rapport: Friendship, Solidarity, Communion, Empathy
Christina Wodtke: Radical Focus
Sarah Wynn-Williams: Careless People

This was, by coincidence rather than design, a few months before the great-but-different Apple TV adaptation brought the series to a much wider audience, so I can still claim to have been into MurderBot (just) before it was cool. [back]

A 3D Year

2025-11-17T00:00:00+00:00

A year ago, I got a 3D printer. A year later, is it gathering dust, or am I still using it?

I’m happy to report, while it’s not quite as busy as it was for the first few weeks, it is still in regular use. While I’ve made quite a few posts over the year (collected at the end of this one), I thought it might be interesting to look back and see what kinds of things I’ve been using it for.

One obvious category (indeed, the thing the printer is doing as I type this) is toys. This was the original impetus for pushing the button on a 3D printer. Specifically, articulated dragons — our youngest in particular loves these. While they’re cool in their way, if this was all the girls were using the printer for I’d be disappointed. However, they’ve been substantially more creative, in particular with doll’s furniture and accessories. The eldest has got very into TinkerCad, and has custom designed numerous pieces, the most ambitious being a working wheelchair for a doll with a broken leg. HeroForge is also proving a hit.

Another cliché is that the main use of 3D printers is to print accessories for 3D printers, and I’ve done my fair share of that. Along with the usual scrapers and buckets, I’ve printed out quite a few mounts for hygrometers¹, and most recently a Y-splitter to allow me to keep the external spool connected at the same time as the AMS. Printing things to better print things is a bit circular, but a nice fringe benefit.

I’ve also found it surprisingly useful for things around the house. Sometimes I find myself printing out things that are better and cheaper mass-produced, like curtain hooks. The benefit of using the printer is that you can get one or two rather than buying an entire pack, and you can get it in ten minutes rather than making a trip to the shops. More often, though, I’m printing something that I couldn’t buy, as it’s custom designed to meet a specific need. An example would be the wall mount for our kitchen scales — we have something that exactly fits the scales we have, and the location where we want to put it. I’ve picked up enough basic CAD skills (OpenSCAD and FreeCAD) that I can create pieces to solve particular problems without too much effort, and doing so is immensely satisfying.

I recently got a Skadis pegboard to display some of my retro computing bits and pieces. 3D printing is the ideal way to get mounting hooks and other attachment to support things of all shapes and sizes, either designed from scratch, downloaded from communities like Thingiverse and Makerworld (where Skadis accessories are a thriving subgenre), or a custom combination of the two. I can see retro computing being another area where the ability to make custom 3D printed parts will be handy; I’ve only done one project in this vein so far, but I can see more on the horizon.

One thing that I’ve not used the printer for much, at least yet, is making parts for keyboards. I’ve made keycaps, but I’ve just not been able devote the time needed for a bigger project. Hopefully, I will soon.

Overall, I’m glad that our 3D printer has continued to prove its worth. It’s not in action every day, or even every week, but it’s great to have on hand, and I certainly don’t regret taking the plunge.

3D printing posts this year:

17 Nov 2024: Adventures in the Third Dimension
23 Nov 2024: Multicolour Waste
29 Nov 2024: First Functional Print
22 Dec 2024: The Cat is Lying To You
24 Dec 2024: Deck the Halls
4 Jan 2025: Keyboard Tray and FreeCAD
12 Jan 2025: You Wouldn't Steal a Boat
31 Jan 2025: Three Shots
18 Jul 2025: Coffee Cup Sleeve
10 Aug 2025: Miniature, Maxiature
3 Sep 2025: A Customisable Cable Clip
19 Oct 2025: A New Material

3D printer filaments are, to a greater or lesser extent, sensitive to humidity, so unless you live in the Sahara you need to keep an eye on it, especially for storage. [back]

A Confession

2025-11-08T00:00:00+00:00

I have a bit of a confession to make. I don’t get Forth. It’s a language I’ve admired from afar, and its approach is genuinely novel and intuitively appealing. However, every time I try to dig deeper, I just… don’t get it.

It’s not that I don’t like different languages; on the contrary, I’m fascinated by them. You’re unlikely to come across Forth these days if you’re not. Nor is my experience limited to mainstream C-alikes; I’m familiar with Lisp and Scheme, ML and Haskell, assembler and SQL. I’ve played with SmallTalk and Prolog and TeX and Scratch. My last job revolved around Verilog and TCL.

I mention that to emphasise the fact that I come to Forth with an open mind. More than that, I come with eager anticipation, as there are a lot of aspects that look good. I like the lack of extraneous syntax — I don’t think I’ve seen a language with less boilerplate and ceremony than Forth — and the use of the stack takes this further by making the flow of data largely implicit. It reminds me of the point-free style in Haskell, putting the focus on what you’re trying to achieve rather than the mechanism by which you’re achieving it. I’m also a fan of the way it erases the barrier between runtime and compile time, and offers an interactive, malleable environment without the overhead that usually entails.

Forth has a reputation of offering both low-level performance and high-level structure, and this is where I run into problems. It certainly has the former, but the more I dig into the details the less convinced I am of the latter. Perhaps this was true when it was conceived. It’s certainly more structured than assembler or BASIC (at least the basic versions), and less rigid that earlier languages like FORTRAN and COBOL. However, even at the time of Forth’s inception in late 60s these weren’t the only options. Its near-contemporary C offers a similar combination of flexibility and performance, with somewhat different tradeoffs, and Lisp was hitting many of the same bullet points almost a decade earlier.

Both of those languages were both useful at the time of their invention, but their core concepts were solid and flexible enough to grow and spawn entire families of progeny and imitators, going far beyond their original scope. Forth, in contrast, seems to have stayed largely in its lane of writing efficient, close-to-the-metal code on a small scale. From what I’ve seen so far, as you move to more complex applications — in particular, more dynamic ones that operate on less uniform data — it feels like Forth’s flexibility and minimalism are working against it.

I’m not giving up, though — enough smart people have extolled the virtues of Forth that I remain convinced that there’s something there. I’m just not getting it. To try and get into the mindset of its heydey, I’ve been exploring Acornsoft FORTH on the Electron, aided by Richard De Grandis-Harrison’s extensive book FORTH on the BBC Microcomputer. Maybe it will click, and even if it doesn’t it’s definitely something different.

Opening the eSun eBox Lite

2025-10-25T00:00:00+00:00

As mentioned in my last post, I recently purchased an eSun eBox Lite filament drier. All was good at first, and it performed well drying out a roll of PETG, but the next time I came to use it I noticed that the fan wasn’t running. It was still within the return window, but as it’s both pretty bulky and pretty cheap, I decided to have a go at fixing the problem instead. This proved straightforward, and so I’d still recommend this as a low-cost and effective drier.

I came across this Reddit post describing a similar problem. It pointed me in the right direction, but the thread is a few years old and doesn’t include any pictures, so I thought it worth writing a quick post to illustrate the process of taking the box apart.

Doing so is pretty straightforward:

Open the drier and remove the two small screws in the heating plate with a Phillips 0 screwdriver (left hand photo).
Close the drier and put it on its side, with the bottom facing you.
Remove the four rubber feet at the corners (right hand photo; you don’t need to remove the middle one), and remove the screws underneath these with a Phillips 1 screwdriver.
Gently slide the bottom of the drier out. Be careful of the wires connecting to the circuit board to the heating element, the control panel and the fan. The panel and the fan can be removed from the upper housing; these just slot into the plastic.

Once the device is open, it’s easy to check the connectors for the various components on the circuit board, which it seems have a tendency to work lose if it’s moved around too much. Sure enough, I reseated the fan connecter and everything was back to working as normal. It’s safe to (briefly) power it up to test it while disassembled, and when you’re happy reassembly is just matter of reversing the above steps.

A New Material

2025-10-19T00:00:00+00:00

Since getting a 3D printer almost a year ago, I’ve stuck to PLA. This is the default material for FDM printers, and for good reason. It’s produced from starch rather than petrochemicals, it prints at low temperatures, and it has decent aesthetic and mechanical properties. It’s a great all-rounder. But it’s not all there is.

My Bambu A1 isn’t enclosed, which rules out higher temperature filaments such as ASA and Nylon. However, there are still a few options. I decided to try PETG, which is similar to PLA but less sensitive to UV and temperature fluctuations, and thus better suited to outdoor applications.

The main downside of PETG is that it’s much more hygroscopic: it absorbs moisture from the environment. Keeping PLA dry is advisable, but with PETG it’s essential. Knowing this, I invested in a basic filament drier (the eSun eBox which also allows you to print with the spool in the box) and some desiccant beads. After a full eight hours of drying, I printed out the traditional test.

The results are shown above; the PETG is the black one, next to one I printed a while ago in red Bambu PLA Basic. I’m pretty happy. First off, the drying seems to have been worth it; I had none of the stringing or popping problems that often come with PETG. The quality is up there with the best I’ve had with PLA, without needing to tweak settings. I also like the glossy finish (but couldn’t manage to get a good photo that showed that off).

So, successful test. Next I’ll try some practical prints; one of my car charger holders is looking a little worse for wear, so a replacement for that is likely to be first on the list. I imagine I’ll still be using PLA for most things, but it’s good to have other tools in the toolbox.

The Language of AI

2025-09-14T00:00:00+00:00

John McCarthy is credited with two major contributions to Computer Science. The first is the term “Artificial Intelligence”, and the second is the programming language LISP. In part due to this entwined history, and in part due to its particular strength, LISP was long though of as the language of AI, but it’s more than that — it’s not an exaggeration to say that pretty much every programming language in use today borrows from LISP to a greater or lesser degree, and LISP itself is still in alive and well in various forms. There’s a lot of history to delve into, but recently I decided to try out something almost equidistant from today and LISP’s origin in 1960: LISP on the Acorn Electron.

This isn’t actually the first time I’ve used that particular implementation. As a child in the 80s, I remember being intrigued and picking up a copy on cassette from a market stall for a few pounds. Unfortunately, the experiment was short-lived, as the software didn’t come with any documentation. I fumbled around trying to get the enigmatic “Evaluate:” prompt to do something useful, but didn’t get anywhere, and soon moved on to less obtuse pursuits.

A few decades later, and I’m returning to it better prepared. Not only do I have both a reasonable grasp of the theoretical foundations and a degree of practical experience with a variety of LISPs, I also managed to find a decent second-hand copy of LISP on the BBC Microcomputer by Arthur Norman and Gillian Cattell, the very documentation I was missing the first time round. So, with the barriers out of the way, what is LISP on an 80s micro actually like?

To my surprise, pretty good. The Electron is a far cry from the Lisp Machines that were its contemporaries, or the mainframes and minicomputers that LISP grew up on. In particular, it has little RAM, and a CPU built around bytes rather than words. To fit inside these constraints, Acornsoft LISP is an interpreter rather than a compiler (as more fully-fledged LISPs tend to be), and it only includes the essentials — so no arbitrary-precision arithmetic, no macros, no conditions. What’s left, however, is a flexible and well-thought-through environment that captures the flavour of LISP, especially for learning and exploration.

This environment is both interactive and transparent, in the best traditions of the REPL¹. This provides the immediacy of BASIC with a far more structured and powerful underpinning. An upside of the interpreter approach is that it puts the equivalence of code and data, one of LISP’s strengths, front and centre. Functions are just lists starting with the symbol LAMBDA, and can be manipulated as such with no intermediaries.²

This transparency forms the basis of one of the more interesting aspects of the system: the interactive code editor. For most people familiar with LISP, “editor” immediately conjures up the image of Emacs and similar editors, but this isn’t that. It’s more akin to the long-obsolete concept of interactive line editors such as ed³ and ex⁴. Instead of moving a cursor around a visible display of the source code, you issue a series of commands to manipulate it, and then print out some or all of the modified text.

What makes the Acornsoft LISP editor different is that, unlike ed and ex, it’s a structured editor — instead of manipulating lines of text, the commands manipulate lists. As functions are, like pretty much everything else, just nested lists, this provides an immensely powerful way to both navigate and edit the code, with the added bonus that introducing syntax errors is impossible. It’s somewhat akin to block-based programming languages like Scratch, and while it takes a little getting used to it’s a great interface when it does click, so much so that I find myself wondering what a modern take would be.

The documentation is equally inspiring. Norman and Cattell start with a thorough and well-paced walk through the fundamentals, and then move on to some more substantial examples. The first, as is required by law in any book on LISP, is a LISP interpreter, followed by some other LISP-related facilities such as a pretty printer, a correct-but-slow implementation of arbitrary precision integer arithmetic, and the internals of the aforementioned structured editor. They then broaden out to more general parsing, evaluation and generation of machine code, demonstrating the suitability of LISP for building compilers (and the authors’ interest in that field). The chapter is rounded off with a bare-bones implementation of a text adventure. This is clear, general and extensible, and shows off the expressiveness and power of LISP.

So, after all that, is Acornsoft LISP a good choice for programming the Electron? If your aim is to produce something for others to use, probably not — aside from the fact that they’d also need to have the interpreter, the overhead is likely to be too much. With such limited resources, you usually want to squeeze as much performance out of the hardware as possible, and that’s not where LISP’s strength lies. However, if you’re programming a one-off solution for yourself, or exploring a problem interactively, it seems like an excellent choice. A modern analogue would be something like Jupyter notebooks. Not bad for a little computer from the early 80s, even if I didn’t realise it at the time. I’m glad I revisited it.

The original photograph behind the Distracted Boyfriend meme is by Antonio Guillem. The books pictured are LISP on the BBC Microcomputer by Arthur Norman and Gillian Cattell, referenced in the text, and Understanding Deep Learning by Simon J. D. Prince, a somewhat more recent take on AI.

REPL: Read-Eval-Print Loop, the interface by which you can type in an expression and see the result of evaluating it. This is nearly ubiquitous for modern languages, but was pioneered in LISP, and and name comes from the implementation in early LISP: (loop (print (eval (read)))) (read it from the inside out). [back]
Interestingly, Acornsoft LISP is a Lisp1 like Scheme, rather than a Lisp2 like Common LISP and its immediate ancestors. [back]
ed is the standard text editor. [back]
Now better known for the visual editing mode that was built on top of it, vi. [back]

A Customisable Cable Clip

2025-09-03T00:00:00+00:00

This design came about because I wanted a clip to attach a car-charging cable to the wall. You can, of course, easily buy these, but I only needed one, and for an unusually thick cable. 3D printing means I can get exactly the part I want, in the quantity I want, and saves a trip to a DIY store or a wait for the postman.

As this is probably not the last time I’ll want to secure a cable somewhere, I decided to do something a bit more general. OpenSCAD’s built-in Customizer allows you to define parameters for your model, which can then be easily and interactively tweaked as shown in the image above.

More importantly, this has become a de facto standard of sorts, and sites such as MakerWorld directly support it. If you upload an OpenSCAD file alongside your finished project, users can customise the model right there on the site before downloading it.

Providing this UI for your model is almost comically easy. You just add appropriate comments to your top-level variables like so:

// Diameter of the cable
Bore      = 15;

// Width of the clip (parallel to the cable)
Width     = 15;

// Thickness of the clip
Thickness = 5;

(In fact, it’s marginally harder to stop things being customisable; you need to add a special /* [Hidden] */ comment. I didn’t originally plan to coffee cup sleeve design customisable, but it was as little effort to tidy up and document the variables as it would have been to prevent it.)

The effortless way this falls out of normal use of OpenSCAD is incredibly powerful, and demonstrates the benefits of rich representations. Rather than just being, say, a list of triangles, like an STL file, an OpenSCAD file is a program to produce your design. More importantly, it’s a declarative program, which lends itself to reuse in contexts other than the one in which it was originally created. OpenSCAD itself looks a lot like a traditional programming environment, with a syntax-highlighted text editor and a “run” button, but there’s no reason that this needs to be the case. With a bit of thought, all sorts of formats could have this level of abstraction, and benefit from the flexibility that it provides.

Cable clip on MakerWorld
cableclip.scad OpenSCAD file

Miniature, Maxiature

2025-08-10T00:00:00+00:00

I’ve been running a traditional Dungeons & Dragons game with my daughters¹. The fundamentals of table-top roleplaying haven’t changed very much since I was doing it at their age, but we came across one thing that definitely wasn’t available back then: HeroForge. It’s a website (we didn’t have those in the 80s) where you can create a 3D model of your character (would be a push on the Electron) and download a file for your 3D printer (we definitely didn’t have those in the 80s).

Imagine a character customiser from a game like Skyrim and you have the basic idea, but the thing that makes it is the breadth and quality of the execution. You could select a few basic attributes, costume items and equipment, but you can also customise every detail, including minutiae of pose and expression. Once you’re happy, you can buy the STL file for printing for about $8 (£6) — costly if you want to build an army², but for a few player characters it’s a very fair price for what you’re getting.

The girls each made a miniature of their character, and we’ve been pretty pleased with the 25mm scale ones for actual play. I printed these on the Bambu A1 with a 0.2mm nozzle; I’m sure I could get better detail with resin printing, but it’s pretty good and to be frank I’ve seen worse in commercially produced metal ones back in the day. Last week, they asked for bigger versions, so I printed them out at 400%. Worked a treat (after a bit of experimenting with supports), and really shows off the models.

Custom miniatures aren’t going to change the game that much, but they’re definitely add an extra point of enjoyment, and aren’t something I’d have even imagined being able to do forty years ago. Living in the future isn’t all bad.

Using the one true version from 1983, of course. I’m not (yet) giving money to those Johny-come-lately Magic the Gathering upstarts. [back]
At least, if you want build an army of unique individuals. Once you have the file you can print out as many copies as you want. [back]

Plus 1 Mini

2025-08-09T00:00:00+00:00

In a recent post, I alluded to my “newly tricked-out Electron”, and promised more detail in a future post. This is that post, and pictured above is the Electron in question, with its new friend the Plus 1 Mini.

While of course dear to my heart, the Acorn Electron was never what you’d call a powerhouse. Its 32K of RAM wasn’t terrible on paper, but the lack of a true text mode meant that much of it was given over to the screen. Moreover, the base unit had limited connectivity, only video (RF, composite and RGB) and a cassette interface for mass storage. What there was was an expansion slot on the back of the machine that gave access to almost all of the internals, and this offered a way forward.

Due to the Electron’s limited success in the market, and the more general problems they were facing, Acorn only released two expansions (the multi-purpose Plus 1 — more on that below — and the Plus 3 disc drive). However, third parties such as Slogger and Cumana picked up the mantle, producing a wider range of peripherals and keeping the ecosystem going for a few years longer than it might have.

More recently, the retro community (such as the fine people on StarDot) have continued this tradition, and there are numerous more modern options that open up interesting possibilities. I’d been eyeing up various of these for a while, but was inspired to take the plunge by this post from Mark Moxon (who’s work on Elite is well worth checking out if you haven’t already).

The Plus 1 Mini, unlike some other options, doesn’t exactly ape the physical form of the Acorn Plus 1 — as you can see in the photo, it’s not quite as wide as the Electron itself — but is similar in spirit in that it offers a grab-bag of useful capabilities in a single package. There are the obvious and characteristic dual cartridge slots, and a joystick port (Atari-style, rather than analogue). Inside are headers to connect a Raspberry Pi Zero to emulate the Tube second processor interface, which is definitely something I want to try out in the future. However, there are two items in particular that make a night-and-day difference to the capability of the machine: 128K of sideways RAM, and an SD card slot.

What makes the RAM sideways is a whole topic in itself, but suffice to say that it’s not just more of the same. The 16-bit address bus means the 6502 can only reference a 64K address space, which needs to cover both RAM and ROM, including the OS. To make use of more than 64K, a fair amount of bank switching is required. Fortunately, Acorn MOS provides a well developed system for doing this. An added bonus is that the sideways RAM isn’t subject to the compromises the Electron makes to share the main RAM with video, and so access is twice as fast.

The biggest benefit, though, is the SD card slot, which essentially emulates a stack of floppy disks¹. Previously I’d been using the excellent PlayUEF to load cassette images, which allows you to pick from a vast library of software and load it with a great facsimile of my 1980s experience. However, I never figured out a good way to get the reverse process working, and thus never had a way to save work from the Electron. This severely limits the kind of experimentation you can do with the machine.

With the Plus 1 Mini, I can not only try out an even wider range of software (including ROM images, which can be loaded into sideways RAM), but can actually do things that last across multiple sessions. I’m excited to see what possibilities this opens up. I’ve already found that the expanded Electron is a significantly more capable (even useful) machine, and it seems clear that it could indeed have been the basis for a thriving ecosystem if history had gone a little differently.

Not far from the BlueSCSI I used to resurrect the Mac SE last year [back]

Coffee Cup Sleeve

2025-07-18T00:00:00+00:00

I’ve just got round to uploading a quick model I made a few weeks ago: sleeves for reusable coffee cups. We have a couple of these basic cups in the car for when we get coffee on long journeys, but they can get a bit hot, and it’s not always clear whose drink is whose. Printing a couple of these in different colours makes them both easier to identify and more comfortable to hold. Not exactly earth-shattering, but a tiny quality of life improvement.

Coffee cup sleeve on MakerWorld
CoffeeCupSleeve.scad OpenSCAD file

lisp-mode

2025-07-06T00:00:00+00:00

I’m having an unexpectedly parentheses-heavy weekend. As well as experimenting with Acornsoft LISP on my newly-tricked-out Electron (more on that in a future post), I had a minor itch at work, and I decided to turn to Emacs to scratch it.

I wanted a quick tool to track what I’m working on, to get a clearer picture of where my time is going. Specifically, I wanted a list of tasks and time spent each day, in a form that I could collate and generate statistics from.

There are innumerable ways this could be done, and I have plenty of experience in quite a few of them. For something that’s just for personal use, a full application toolkit is almost certainly overkill. The last time I did this exercise I used Excel, which worked pretty well on the statistics side but left the entry of the data more manual than I wanted, so this time I wanted to try something else. I decided to return to an old staple.

Within about half an hour, I’d put together something serviceable — a new editing mode for an simple, ad hoc format that allowed me to quickly enter timestamped entries in a few keystrokes, while retaining all of Emacs’ more general editing facilities. Reading this into a Python notebook to analyse will be similarly easy when I get to it.

As mentioned, I could have done all of this in a more powerful and general application toolkit, but that would have probably taken longer than I could justify. The advantage of Emacs (and Excel, and a few other similar systems) is that they provide a rich structure to tweak to your specific needs. The interesting question is in the details; in this case, Emacs’ system of editable text buffers was a better fit that Excel’s grid of cells, but often the converse is true. It makes me wonder, are there other useful structures with similar properties? It’s a space that seems both fertile and under explored.

Surprise and Delight

2025-07-01T00:00:00+00:00

The Aerial screensaver has always been one of my favourite quality-of-life details of the Apple TV box, and I was happy to see it arrive on macOS, with the bonus touch of slowing and becoming the desktop background when you unlock the computer.

For a long while I stuck with the default Sequoia forest video, but recently I fancied a change, and opening up Settings I came across an absolute gem that I had no idea was there, the “Macintosh” screensaver.

This consists of extreme, animated close-ups of UI from the original 1984 Mac, slowly panning over a colour gradient background. Not only is the effect superbly executed, but the content is well chosen — recognisable applications such as MacPaint and MacWrite, the iconic cursive “hello”, and (slightly anachronistically) the “here’s to the crazy ones…” text.

I’m not entirely sure how this ended up in macOS. Apple are now a globe-spanning behemoth serving an incredibly broad customer base. Most of their customers weren’t born in 1984, and I’d imagine most of those who were wouldn’t recognise what they were seeing. The fact that something so niche made it through the big company machinery is surprising, and it delights me a little every time I open my computer.

Update 2025-07-18: This morning I noticed another nice touch; the time on the virtual Mac is correct, and updates live. I’d assumed it was basically a layered motion graphic, but apparently they’ve gone to even more effort than I thought. Brilliant.

Don't Finish My Sandwiches

2025-03-29T00:00:00+00:00

When they first came along, I was sceptical about the merits of using an AI (specifically, a Large Language Model) to help you code. However, the world doesn’t stand still, especially the world of technology, and it’s been a busy two and a half years. Coding assistants have become more sophisticated and widespread, and for a while I’ve been dipping my toe into the water and trying them out myself. As such, I thought it was time for an update.

My assistant of choice is Github Copilot, not through any sophisticated evaluation process, but purely through convenience. As a user of both Github and VS Code, things have reached the point where it’s more effort not to try it out in some capacity. I’ve been doing so on and off for a few months, on small tasks.

One thing that quickly struck me was poor performance in the functionality most people would first think of when thinking of coding assistants: autocomplete. As with many things LLM, this produces results that at first appear beguiling, verging on the miraculous, but fall apart on closer inspection.

To illustrate, here’s a recent example from my book log (which I happen to edit in VS Code). First, an example of it producing a result that genuinely impressed me (autocomplete suggestion in italics):

- title: "All Systems Red: The Murderbot Diaries"
  author: Martha Wells
  url: https://www.marthawells.com/murderbot1.htm
  start: 2025-01-28
  end: 2025-01-30

- title: "Artificial Condition: The Murderbot Diaries"

Here, Copilot has suggested the title of the next book I’m reading based on the data in the previous entry. Not only has it formatted it correctly, it’s also factually accurate — “Artificial Condition” is indeed the next entry in Martha Well’s excellent MurderBot series. While it’s possible that someone else keeps a log of the books they’ve read in a YAML, using the same keys and structure as me, is also making their way reading through The MurderBot Diaries, and Copilot is just regurgitating an item from its training set, that seems unlikely. More likely, it’s actually working as advertised, and weaving together several different patterns (YAML syntax, properties of books, and the sequence of titles in that particular series) in a complex, multi-dimensional way. This is great demonstration of how LLMs go way beyond simpler statistical techniques.

It turned out that in this case the prediction, while entirely reasonable, was incorrect, as I wasn’t reading the next MurderBot book immediately (I like to spread these things out). No big deal — even if autocomplete doesn’t get it right every time, it’s still useful, and I can just ignore the suggestion and I’m no worse off. However, when I supplied the title of the next book I was reading, the suggestion was somewhat less helpful:

- title: "Monsters: What Do We Do with Great Art by Bad People?"
  author: "Claire Dederer"
  url: https://www.penguinrandomhouse.com/books/669579/monsters-by-claire-dederer/

If Copilot had done what it appeared to do — found a URL for a site about the book in question — it would have been at least as impressive as the previous example, if not more so. Fortunately, I had sufficient remaining scepticism to check the link, and confirmed that this was not the case. Instead, it produced something that looks like the right URL (this is the format of URLs used by Penguin), and it’s inserted the title and author in the way you’d expect them to appear. However, this is done without any reference to what’s on the other end of that link; the sequence of digits is basically random, and happens to resolve to “The Count of Monte Cristo”.

This is absolutely the way you’d expect an LLM to fail — in their basic form the way they work is to to produce a probable (and thus plausible) continuation of their input, with no reference to external reality. There’s some correlation between this probability and truth, but the correspondence is far from complete. More recent techniques ground the LLM with factual information in various ways, but as this example (by no means usual) shows the gap remains.

The above example is perhaps unfair, as it’s not really the kind of coding task that Copilot is targeted at. However, in my experience, using Copilot’s autocomplete while programming is worse. The kind of errors that turn up are the same, but have the potential to be both subtler and with more widespread impact. More damningly, LLM-based autocompletion compares very poorly with what it’s replacing.

I clearly remember code completion coming into the mainstream with the advent of Intellisense in the late 90s. Those of us who were already used to programming without it derided the idea as wasting more time than it saved, and we had a point. The predictions were often wrong, either in absolute terms or being non-idiomatic and overly verbose. However, Microsoft and many others didn’t stand still, and the quality of these systems steadily improved. Fast forward twenty-five years, and traditional (non-LLM) code completion is astounding; fast, reliable and idiomatic. Advances in areas like type systems and static analysis (even in dynamic languages like Python and TypeScript) mean that suggestions are not only correct but informative — while it doesn’t obviate the need for documentation or understanding, code completion can serve as a valuable aide-mémoire, avoiding the need to look up minor details and giving you the confidence that your recollection is correct.

Replacing the traditional, structured approach with an LLM completely undermines this benefit. If it offers a list of named parameters for a function I’m calling, I can no longer view that as a reference, as it might have made some of them up. It will, of course, seem plausible, but that makes it more dangerous, not less. After a few days of trying to do actual programming work with Copilot completions, I turned them off and went back to the old kind. I’ve been very happy with that decision.

Does that mean that, for me, Copilot is a bust? Not at all. There’s another mode of interaction that feels like a far better fit to the strengths and limitations of generative AI, and the more I use it the more I’m convinced that it could live up to the hype. I’ve become a big fan of Copilot Chat.

Here, instead of code completion, you interact with Copilot in a separate dialogue in a sidebar. “Chat” is absolutely the right name, as it looks and feels like a text conversation with a human being (and, absurd as it may sound, treating it as such may well yield better results). You can ask it how to perform a task or use an API, and it will produce a lucid, coherent answer with examples. Because it’s running in the context of the IDE, it has access to your own code as context, and this is evident both in the incidentals (variable names and so on) and in the fact that it incorporates relevant information not explicitly stated in the question, such as the libraries you’re already using.

Crucially, this isn’t a one-shot process. You can ask questions about the results, ask for changes or clarifications, and even correct mistakes. This last point is, I think, the one that makes it feel like a better interface to Copilot. Today’s LLM-based systems are prone to hallucinations, and it may well be that this is a fundamental property that will never go away. With autocomplete, these render individual suggestions useless and the system as a whole untrustworthy. In the context of a chat, you still need to be aware of them, but there’s a way forward with that awareness.

The first attempt to exploit a new technology is usually to use it as a drop-in replacement for an existing application. Ben Thompson frequently cites the example of advertising on the Internet, which initially aped print advertising in placing display ads alongside content. In most cases, it’s a poor substitute, and the new technology only really takes off with the advent of a different approach that plays to the strengths of the new medium (in that example, feed and search ads).

Of course, it’s not a given that such an approach will be found; most technological developments turn out to have little or no long term impact, whatever their boosters may think. For a while, I thought generative AI may fall into that camp, and my experience with code completion backed that theory. However, taking a step back, I’m now coming round to the idea that that is just the technology being misapplied. Chat interfaces, on the other hand, may or may not be turn out to be the best way to take advantage of the capabilities of LLMs, but they’re enough to suggest that there’s some there there.

The header image is a combination of photos by Sara Cervera (sandwich) and Matt Artz (spanner) from UnSplash.

The Beginner's Mind

2025-02-10T00:00:00+00:00

One of the things I’m enjoying about dipping my toe into CAD is the chance to approach something as a beginner. I rarely get — or perhaps make — the opportunity to do something that’s both unfamiliar, and low enough stakes that I can take risks and take my time. I’m making a conscious effort to not bring my preconceptions from adjacent fields, and not rush towards the first thing that will achieve my practical ends (although I freely admit that I sometimes fall short on both counts). There’s a wide world of new concepts and ideas, and it would be a waste to simply give the ones I already have a fresh coat of paint. Once I know the lay of the land, I imagine I’ll be able to put my old experience to work alongside the new, but for now I’m going to go slowly, keep my eyes open and fresh, and learn.

Three Shots

2025-01-31T00:00:00+00:00

Most keys on most keyboards are labelled in some way. Usually, these labels (“legends”) are just printed on top of the keycap, the bit of the key you actually touch. But because you’re actually touching it, the legend wears off over time. As you move into fancier keyboards, there are various ways to remedy this. The most indestructible are double-shot keycaps, where the legend is actually a separate piece of plastic that goes through the main keycap like the letters in a stick of Blackpool rock. This can let your tasteful RGB lighting shine through, but more importantly means the legend will never wear out.

Producing intricately-enmeshed plastic shapes is an area where 3D printing in general, and multi-material 3D printing in particular, stand out, so since getting my printer I’ve been itching to try and make some keycaps of my own. It also offered a perfect opportunity to try out my new 0.2mm hotend (the default is 0.4mm).

Rather than trying a full set straight off the bat, I decided to go for something more modest. I occasionally use my first mini-keyboard as a macropad, but recently realised that the otherwise-unused outer rows of my Corne would do just as well. Updating the firmware was straightforward¹, so I just needed half a dozen keycaps with custom symbols.

OpenSCAD coupled with colorscad seemed like the tools for the job, and the comprehensive KeyV2 project on GitHub provided a flexible way to create keycaps in a wide variety of profiles. Importantly, this includes the DSA profile that I was already using, so I started with that.

It was easy enough to add an embedded shape in a contrasting colour, but when I printed it I ran into an in-retrospect-obvious issue; the dish at the top of the key produces some very obvious layer artefacts when sliced:

These kind of artefacts are unavoidable in FDM printing when making a surface at a shallow angle to the plane of the layers. You can sometimes minimise the impact by positioning your model at an angle, but that often introduces other problems — for example, here the sides of the keys aren’t flat, so I’d need to add support. A more general approach is post-processing the print. I had a go at sanding my test prints down, but while this produced a decent feeling keycap, I couldn’t get a visual finish I was happy with. At this point I could have moved on to more advanced finishing techniques like vapour smoothing, but I decided to think laterally.

I decided to forgo the dish, and make the top of the key flat. The keycaps could then be printed face down, which not only solves the layer artefacts, but picks up a nice texture from the build plate. Moreover, as the legend only needs to go through the top surface rather than the entire height of the key, only the first few layers contain multiple colours. This significantly reduces both time and waste.

With this approach in mind, I started putting together the symbols. Looking at my first double-shot design, a thought occurred to me: why stop at two? Putting together three or more different colours would be tricky using conventional production techniques, but not for 3D printing. With nothing stopping me, I went ahead with a red-and-white colour scheme on black keys, and I’m pretty pleased with the result:

The keycaps look great straight from the printer, and have a nice feel thanks to the texture. The lack of a dish might make them less comfortable for regular typing (or perhaps not — most modern, mass produced keyboards have flat keys and get away with it), but these are function keys and so it’s not an issue.

The OpenSCAD source file is here: CorneExtras.scad. I’ll not hold it out as an example of good style; in particular, there’s more boilerplate and repetition than I’d like. I’m not sure if this is due to my own lack of experience with the language, or its limitations. Regardless, it should hopefully serve as a useful starting point if you want to have a go at making something similar yourself.

Generally speaking, I don’t hard-code key sequences into the firmware, but instead configure the macro keys as high-number function keys (F13, F14…) and map them to functions in BetterTouchTool. This allows for more advanced actions, and avoids the need to re-flash the firmware every time I want to reconfigure them. [back]

You Wouldn't Steal a Boat

2025-01-12T00:00:00+00:00

A quick, tongue-in-cheek joke about the current absurdity surrounding the licensing of 3DBenchy, the until recently beloved de facto mascot of 3D printing. Available on MakerWorld (CC BY-NC-SA, of course).

Keyboard Tray and FreeCAD

2025-01-04T00:00:00+00:00

Since going remote at the start of the pandemic, I’ve had a standing desk setup at home. Rather than an adjustable height desk, I kept my existing desk and put the monitor on a tall VESA mounting arm. Combined with this, I’ve used a variety of stands to sit on the desk and raise the keyboard and trackball to elbow height. These work fine, are a bit cumbersome to move out of the way when you want to use the desk at normal height. So, as a little holiday project, I decided to upgrade to an arm-mounted keyboard tray.

My initial plan was to mount this on the same pole as the monitor, but it ran into a snag — the arm I’d found was from different manufacturer, and was designed for a pole a few millimetres thicker. What I needed was a plastic sleeve, and as it happens I now have a way to make random plastic parts on demand. A few lines of OpenSCAD and twenty minutes of printing, and I had a simple sleeve to adapt the arm to the existing pole. Problem solved. Well, the first problem, anyway.

When I connected everything back up, it became rapidly apparent that the action of typing caused the monitor to wobble quite a bit. This would be annoying at the best of times, and even worse on video calls (as the camera is on top of the monitor). I reconfigured everything so that the keyboard was on a separate pole, but this didn’t solve the issue; both were attached to the desk, and the vibrations from typing still wobbled the screen to an unacceptable degree. Clearly more was needed.

Taking a step back and looking at it, I concluded that the best approach would be to add an additional brace attaching the top of the pole to the wall (the bottom remains fixed to the desk; I didn’t want to ditch the pole entirely as it allows the height of the keyboard to be adjusted). Again, the ability to make custom parts to the exact specifications needed saved the day — I’m starting to see that this will be a complete game changer for DIY jobs around the house.

I could have designed the brace in OpenSCAD, but I took the opportunity to try out FreeCAD. Where OpenSCAD is essentially a programming environment for Constructive Solid Geometry, FreeCAD is a lot closer to a traditional CAD system. Given my background and prior experience, I’d expect the former to be more natural, but to my surprise I found the latter to be a better fit for more complex designs. It’s early days, and I suspect that I’ll end up using both packages in different contexts, but from what I’ve seen so far the extra power and flexibility of FreeCAD is worthwhile even for a beginner like me.

This capability comes at the cost of complexity; my mental model of how FreeCAD actually works is very much a work in progress, and the UI is a mass of toolbars, views and states that I’m still groping around as if blindfolded. How much of this complexity is inherent to a “real” CAD package, and how much of it is due to shortcomings specific to FreeCAD, remains to be seen. I might take a look at Fusion 360 as a point of comparison, but its “free for hobbyists” license makes me wary of investing too much time into it, at least at this stage.

Back to the keyboard tray problem, I got a first version designed pleasingly quickly, but on printing it out realised that I’d based it on the measurements of the narrower pole and so the piece wouldn’t fit. Suitably chastened, I fixed the mistake, and while I was there added a few refinements like countersinking the screw holes and adding fillets. This time, I stopped the print after the first few layers to provide a piece that could physically confirm the sizing. It was spot on, so I printed the whole thing, and installed it.

I’m pleased to report that it worked like a charm — a rock solid keyboard tray arm, and no vibration of the monitor. It was a bit more of a roundabout route than originally intended, but I got there in the end, and learned some things along the way. I’ll call that a win.

Books of 2024

2024-12-31T00:00:00+00:00

I’ve always enjoyed reading, both fiction and non-fiction, and try to make time for it as much as I can. A few years ago I thought it would be nice to keep a record of what I’ve read, but I’ve never got on with reading-based social services such as GoodReads and BookWyrm. Hence, I decided to go for something more basic: for a while now, I’ve recorded what I’m reading, and when, in a simple Jekyll data file as part of this site. This is mainly for my own notes, but also helps generate the /now page. What’s more, now that I’ve been using the system for a full calendar year (I started mid-2023), I can use it to look back on what I’ve read over the last twelve months.

(The yellow bars indicate when I started and finished each book; the open ones are the end are for books I still have on the go.)

This year, the standout discovery was Nichola Griffith. I picked up Hild in January as it’s set in a part of the world with which I’m a little familiar, at an interesting period in history. Hild delivered on that, but more importantly it’s enormously evocative of a very alien period, has a plot that rattles along, and one of the best cast of characters I’ve read in a long while. A truly surprisingly bombshell dropped literally in the last couple of pages make the follow-up Menewood pretty much non-optional. I also read and enjoyed Griffith’s first novel, Ammonite, and will definitely be returning to her again.

I’ve also returned to a familiar author: William Gibson. He’s mostly know for his pioneering role in the development of cyberpunk, in particular Neuromancer and its sequels. The Bridge trilogy (Virtual Light, Idoru and All Tomorrow’s Parties) is less well known, but reading it for the first time I’ve been struck how many ideas that are real today — cybercrime franchises, social media, deep-fake sextortion — turn up pretty much fully-formed in fiction from a quarter-century ago. They’re also excellent books in their own right, and I’m very much looking forward to the concluding part of the Jackpot trilogy coming out (hopefully) in 2025.

Moving to non-fiction, The High Frontier and The New World on Mars was an interesting look at the arguments in favour of humanity moving beyond this planet, and made an good counterpoint to the more sceptical A City on Mars that I read at the and of last year (my brother was keen I got both sides of the picture). Rereading The Humane Interface provided an interesting perspective on the 40th anniversary of the Mac, and I’m working on-and-off through both Understanding Deep Learning and Google’s Site Reliability Engineering in the context of work. Both are available online for free if you’re interested in the subjects.

Overall, I’m glad I started recording what I’m reading, and have enjoyed taking the time to look back over it as I write this review. I think this might become an annual feature.

For reference, here’s a full 2024 list:

Margaret Atwood: Cut & Thirst , My Evil Mother
Betsy Beyer, Chris Jones, Jennifer Petoff and Niall Richard Murphy (Editors): Site Reliability Engineering
Octavia E. Butler: Parable of the Sower
Christopher Evans: The Mighty Micro
Neil Gaiman: Norse Mythology
William Gibson: Virtual Light , Idoru , All Tomorrow's Parties
Nicola Griffith: Hild , Menewood , Ammonite
Kazuo Ishiguro: When We Were Orphans
Steve Jobs: Make Something Wonderful
Cal Newport: Slow Productivity
Gerard K. O'Neill: The High Frontier
Lewis Packwood: Curious Video Game Machines
Simon J. D. Prince: Understanding Deep Learning
Jef Raskin: The Humane Interface
Eric Ries: The Lean Startup
N. K. Sanders (translator): The Epic of Gilgamesh
Janelle Shane: You Look Like a Thing and I Love You
Steven Vickers: ZX81 BASIC Programming
Gordon Welchman: The Hut Six Story
Alex Wiltshire & John Short: Home Computers: 100 Icons that Defined a Digital Generation
Gabrielle Zevin: Tomorrow and Tomorrow and Tomorrow
Robert Zubrin: The New World on Mars

A Nerd Trifecta

2024-12-30T00:00:00+00:00

A little while ago, I came across a video that combines three of my current nerdish interests, namely retro computers, mechanical keyboards and 3D printing:

If you’re not already seen it, I highly recommend giving it the time. The sheer amount of effort and attention to detail that goes into the project is incredible. Note that this isn’t a restoration of an old machine, or a recreation of a classic with new parts. This is a Mac that never existed as anything more than a non-functional model. The Flat Mac could not have been made in 1984, due to the limitations of battery technology if nothing else, but it’s now in the world, albeit as a one-off.

Deck the Halls

2024-12-24T00:00:00+00:00

I was listening to the youngest practice Christmas songs on the piano, and I had a terrible idea. In any case, Merry Christmas.

The Cat is Lying To You

2024-12-22T00:00:00+00:00

The cat needs to be fed. The cat is very insistent on this point. The cat can’t believe that you think someone else might have already fed her.

THE CAT IS LYING TO YOU.

Get one step ahead of feline deception with this handy print-in-place marker; attach it to the cat food canister, or mount it near the food bowl, and it will be clear at a glance if it’s time to feed.

I’ve published my first model — a flipping label to indicate when you last fed the cat — to MakerWorld, Bambu Labs’ model sharing community. It’s not that complex, and the top-layer print quality is frankly appalling, but I was pleased to make something useful, especially with the print-in-place mechanism.

Stuck in the Middle

2024-12-16T00:00:00+00:00

On a recent episode of ATP, Casey mentioned that one of the issues with an ultrawide Mac display, such as the one now provided by the Vision Pro, is the long trek to the left side of the screen to access the menu bar. This wasn’t an issue in 1984 when the screen was only 9”, but as displays have grown it’s become more and more of a factor. This apparently lodged somewhere in the back of the brain, and percolated up again in the form of a strange idea:

(Click for a full width version — this is of course a mockup, rather than implemented software.)

The idea is hopefully simple and obvious; the menus, starting with the Apple menu, starts in the centre of the menu bar and goes left, whereas notification area, starting with the clock, grows to the right, again from the centre. On modern Mac laptops this means they grown from either side of the notch, as shown, but on older hardware and external displays the Apple menu could act as an anchor.

This design stems from the observation the the easiest place to reach on the menu bar is the centre, rather than either end. Traditionally, the most used items are placed at the extremes (for example, the application and File menus, and the clock and control centre) — these end up closest to the centre¹.

The only downside of this change is that you only have half the available width for each side of the menu bar, but Apple have largely crossed that bridge by introducing the notch, and in my experience it doesn’t seem to be a major problem in practice. The new design would require a different solution (perhaps an overflow menu?), but it seems like a win overall.

I don’t expect that Apple will make this change, but if they did it wouldn’t be entirely without precedent. Way back at the turn of the millennium, Mac OS X Developer Preview 3 put the Apple menu squarely in the middle of the menu bar, mirroring the placement on the iconic iMac. That never made it to the final release, but perhaps it’s an idea who’s time has come.

As an added bonus, putting the clock right next to the webcam means you can check how long your meeting is dragging on for while appearing to be really engaged. [back]

Hacking Like It's 1981

2024-12-14T00:00:00+00:00

Back in July, I encountered a bit of weirdness in the way that the ZX81 addresses RAM when it only has a single kilobyte. I was reminded of this listening to the latest episode of Risky Business, which reported on an interesting and decidedly 21st-century attack.

AMD’s recent processors offer SEV, a suite of features to protect Virtual Machines from compromise even when the attacker (say, a cloud hosting provider) has physical access to the processor. The BadRAM undermines a key plank of this in a pleasingly straightforward way, by causing the system to report that it has twice as much RAM as it actually has. Just as with the ZX81, the additional bit of the address (just the one in this case) is ignored, meaning each physical location can be referenced by two address. One of these is correctly protected by SEV, but the other is up for grabs.

It’s some fascinating security research in its own right, but also highlights the similarity of computers today and those of forty (and more) years ago. We’ve added many layers of capability and complexity, and scaled up by orders of magnitude on every axis, but underneath all of that many of the fundamentals are unchanged. Understanding those fundamentals is still important.

First Functional Print

2024-11-29T00:00:00+00:00

About the same time as my educational foray into multicolour printing¹, I decided to put the printer to work doing something useful: my first functional print. I had an almost-complete design already, that I’d produced while getting started with OpenSCAD, so it was just a matter of turning it into reality.

Regular readers may recall my project at the start of the year to revive a Mac SE in honour of the 40th anniversary of the Mac itself. At the heart of that was a BlueSCSI SCSI emulator. I chose to mount this internally in the location of the old hard drive, which was great for preserving the feel of the machine, but made access to the SD card storing the data an issue. I alleviated this somewhat by adding a simple extension adapter, but there was no easy way to mount it, and so it just dangled out of the back of the case.

The obvious solution was to make a custom blanking plate to fit into SE slot in the back of the Mac (if you’re not familiar, picture a PCI slot and you’re in the right ball park), with a hole sized to fit the extension cable’s card reader. This turned out to be pretty straightforward and a good started project in OpenSCAD (the leftmost image). I exported the design, imported it into Bambu Studio (the middle image), and sliced and printed it without issue.

I tried the finished piece in the bracket into which it would be installed, and found a few things. Firstly, I’d assumed I’d be using small self-tapping screws to fix the plate in place, and designed in a couple of pilot holes. On the off chance I tried a couple of M2 bolts I had laying around, and these fit perfectly. Less positive was that my measurements had been a bit off — the screw holes were a few millimetres too close to the centre, and the slot for the card reader was a little too small.

I grabbed a set of files and started to try and correct the latter problem, but the realised that I didn’t need to. I could just go back into OpenSCAD, adjust the model, and print out another version. While there, I made the whole panel a little thicker as well. This new version was spot on, and I epoxied the reader in place (the rightmost image), and reassembled the Mac with its new, tidier storage.

This workflow wasn’t something that I’d thought about, but on reflection is a major advantage of having your own 3D printer rather than using a service or MakerSpace. A key use case for 3D printing has always been rapid prototyping, and this still applies when the final item is 3D printed itself. Printing another version of a part isn’t as light-weight or cheap as recompiling software, but it’s a hell of a lot cheaper than fabricating a silicon wafer or retooling a factory. Having a (relatively) rapid turnaround means you can iterate on a design and get to the best final version quickly, rather than try to anticipate every problem up front, and bodge the ones you don’t catch for a sub-optimal result. It brings some of the agility of software into the real world.

A note of chronological clarification: I’m a bit behind on writing things up, and both this and the previous post relate to the weekend of the 10th of November. [back]

Multicolour Waste

2024-11-23T14:28:50+00:00

When I took the plunge and bought a Bambu A1, I got the AMS Lite multi-material system that allows you to load four different filaments at once and automatically switch between them. I decided to go for this as it’s significantly cheaper to get it bundled that buy it at a later date, and it seemed like a big step up in quality-of-life in terms of not having to swap spools all the time, and automatically switch over to a new one when the old one runs out.

The headline capability of the AMS Lite, though, is multicolour printing. I don’t see myself doing much of this, but it’s nice to have the option, and after I’d tried a few standard prints with the included filament sample I decided to give it a go. The way the AMS implements multicolour printing, namely swapping multiple filaments in a single print head, entails quite a bit of overhead both in time, and in waste plastic as the printer flushes out the previous one. However, I’d not quite steeled myself for just how much an overhead this was.

Firstly, time. The standard, single-colour Benchy that was my first print took 21 minutes. In contrast, the identically sized four-colour Benchy I found as a test¹ took over nine hours — so long that we had to pause overnight (on the plus side, the print resumed perfectly in the morning). This is a massive increase, but in the grand scheme of things is probably manageable.

More striking is the amount of waste plastic. Every time the printer feeds in a new filament, it needs to extrude a small amount of plastic to clear out the nozzle. Each poop (this appears to be the term of art) is only a fraction of a gram, but if you need to do up to four for each layer, over hundreds of layers, it adds up. Moreover, when printing multicolour, it’s also advisable to print a priming tower, an extra area on each layer to ensure the new colour is coming through cleanly before printing the model itself. Together, the tower and the poop added up to more than ten times the material used in the model itself:

This model is intentionally a bit of a stress test for multicolour prints, but nevertheless isn’t doing anything pathological — it’s probably a good analogue of what you’d get if you applied colour to an existing model without any particular thought about optimising it. That said, I also didn’t put any effort into the print settings; I just hit go.

The amount of waste in this print is somewhat shocking, but it represents a worst case. This video contains some tips to significantly reduce waste, and the latest version of Bambu Studio is smarter about the purge amounts between different pairs of colours (basically, you need to purge less going from a lighter colour to a darker one). What’s clear is that this isn’t going to be something that works straight out of the box; a bit of effort and thought is required.

One key takeaway is that the waste is very dependent on the number of layers, rather than the volume of the model as a whole. Hence, I can see myself using it for things like signs — large, flat pieces that would benefit from embedded colour changes but have relatively few layers. This seems like an instance of a larger point; you need to consider the printability of your model throughout the whole process, rather than just throwing it into the slicer at the end and assuming you’ll get good results. It’s this kind of lesson that makes picking up a new hobby enjoyable.

“3D Benchy AMS test - 4 colors”, remixed by Liam Meakins — this appears to have been removed from MakerWorld since I printed it. [back]

Self-host Your Email on the Modern Internet With This One Weird Trick

2024-11-23T09:46:58+00:00

Back in the early 2000s, when I first bought this domain and started this site, self-hosting your own email was common. If you were running a personal web server, it was just something you did. Over the years, though, things got more complicated. An arms race developed between spammers and anti-spam technology, and for your email to be useful you needed to keep up. Encryption became an increasing requirement, bringing with it the hassle of managing certificates. Later, an alphabet soup of technologies (DKIM, DMARC, SPF) sprang up that you needed to follow to prove you were a legitimate sender. All of this happened against a background of email becoming increasingly centralised — if you weren’t one of the big providers, it was hard to get your mail delivered at all. By the start of this decade, the received wisdom was that hosting your own email wasn’t a practical option.

Through a combination of inertia and ill-advised pigheadedness, I’ve been a holdout. However, I was starting to waver — even though I jumped through all of the hoops, and was careful not to be running an open relay, my mail was still finding itself on the naughty list more than occasionally, and I was contemplating throwing in the towel and moving to Fastmail or similar. Then I came across this one weird trick that solves the problem, and with the move to Mythic Beasts I finally got around to fully implementing it.

I’ve been using Mailroute for years for spam filtering. The integration is incredibly simple and clean — you just point your MX record to their servers, which scan and filter the incoming mail and then pass the legitimate messages on to your own server via normal SMTP. About a year ago I decided to investigate their outbound service, included in the subscription, and realised it would address the deliverability problem.

Again, it’s a very simple integration; you just configure your MTA to send all outbound mail to theirs, and they’ll route it on. The mail clients on your laptop or phone still talk to your own server; Mailroute’s is limited to specific IP addresses to prevent abuse. The net result is that your mail gets sent with their reputation, and maintaining that reputation is the responsibility of experts who are paid to do it. Even better, it means you no longer have to run an MTA accepting connections from the entire internet, and so can sleep a little easier.

When setting up my new VM, I decided to ditch my decades-old, crufty Exim configuration and start afresh. I’ve now got a largely stock “smarthost”, with a few local tweaks, and everything is running like clockwork.

Mailroute isn’t the solution for everyone; in particular, the price quickly mounts up if you have multiple users. Self-hosting email itself is probably not the right option for most, either — there are plenty of good managed email providers, and as long as you own your domain you’re not tied to the first you pick — but, if you do want to give it a go, Mailroute or a similar intermediary solves a lot of the problems that have cropped up over the years. There aren’t many of us left, but we can hold out at least a little longer.

Adventures in the Third Dimension

2024-11-17T00:00:00+00:00

3D printing has, for a few years now, been something that I’ve watched with interest from a distance, but never quite felt compelled to plunge into. This began to change when the girls found some cute articulated dragons in a souvenir shop. When they learned that these had been made by a machine that you could actually have in your house, they were immediately hooked on the concept. This turned out to be the push I needed to start looking more seriously.

The world of hobbyist 3D printing has come a long way in the 15 years since the patent on FDM lapsed. The printers of today are leaps and bounds ahead of those from even a few years ago, in terms of quality, reliability, and, in particular, ease of use. While it’s still possible to get a printer that is also a project, I decided that (for the moment, at least), we were more interested in the capabilities than the device itself. Hence, I wanted something simple, dependable and beginner friendly. Bambu Lab kept cropping up in both personal recommendations and reviews as a stand-out in these areas, and they happened to have an early Black Friday sale on. I bit the bullet and ordered their entry-to-mid-range A1 Combo.

Delivery took a week or so, which gave me time to clear out a bit of space in the spare room, and reinforce the desk to make sure the printer had a solid home. Unpacking and setting it up was a breeze, and (with a quick check on my thinking on Reddit) I was soon holding my first Benchy, pictured above.

The A1 itself lived up to the hype in terms of ease of use. In fact, it was so straightforward that it felt like cheating, with none of the manual calibration, tweaking of settings and crossed fingers traditionally associated with 3D printing. Modern printers in general, and Bambu Lab’s in particular, have really reached the point where you can just use them. There’s still plenty of tweaking and learning that’s possible, but you get pretty good results out of the box with a minimum of fuss. The question remains, though: why?

When you get, say, an upgraded iPhone, it does basically the same things as your old one, just better and more. In contrast, getting a 3D printer opens up something entirely novel, a new capability that you didn’t have before. This is exciting, and increasingly rare in the realm of technology. The ability to design something unique on screen, and then press a button and have it in your hands¹ feels truly magical.

3D printing is not yet quite mainstream, either in terms of cost or ease, but it’s not far off. In some ways, it’s reminiscent of the microcomputer revolution of the late 70s and early 80s, where home computers went from something that you had to build to something that you could buy ready to use. This kicked off a flowering of creativity and exploration, making it (then and now) an interesting time to be getting into the area.

More important than the big picture, though, is the happy surprise of the degree to which it’s fired my imagination (and the girl’s). My mind is fizzing with what to make next.

Some sequences shortened. [back]

Moving to Caddy

2024-11-08T00:00:00+00:00

As part of my recent host move, I decided it was time to review my web server situation. Specifically, I decided to move on from Apache. It’s served me well over twenty years, and adapted to all of the changes I’ve thrown at it (most notably HTTPS), but my configuration was a tangle of two decade’s of cruft, and since I started other options have emerged that would be more directly applicable to my use case. The switch presented an opportunity to start with a clean slate, so I took it.

My initial plan was to move to nginx, as I’m already very familiar with it, and was confident it would do what I need. However, my friend and colleague Cal suggested I take a look at Caddy, and this turned out to be a very good call.

Caddy is a relatively new kid on the block, and I’d only previously looked at it in its very early days. Coming back to it, it’s now a fully-fledged, production-ready web server, with a few tricks up its sleeve. The most obvious, and most widely applicable, is that it automates the serving of HTTPS, right down to requesting certificates from Let’s Encrypt. Moreover, it touts streamlined configuration that’s so simple you can be up and running in minutes, rather than hours.

This all sounded too good to be true, but I gave it a go and it was 100% on the money. I had a fully working copy of this site, including HTTPS, up in well under 15 minutes (including installing Caddy itself), and by the end of half an hour had sorted out all of the weird redirection and legacy HTTP stuff I wanted to and switch over the DNS. It really is as easy as they claim, at least for the sort of things I want to do.

Of course, nothing is perfect. I suspect there are plenty of edge cases that it can’t handle as well as other options, and for very high volume usage you can find better performing options. Those caveats only apply to a small minority of users, though. If you are within the (very wide) range of what Caddy can do, it’s hard to beat.

What's In A Name?

2024-11-02T00:00:00+00:00

My recent post was accompanied by a picture of the Lion and the Unicorn from Through the Looking Glass, flanking Alice holding a cake. This isn’t as random as it might seem. My new server is called unicorn (partly in a nod to Mythic Beast’s traditional branding), and the old server was called cake.

Those names aren’t random either; I follow the venerable sysadmin tradition of naming computers according to a theme. In fact, I have two schemes; one for my personal machines, and one for my work ones. See if you can guess what they are:

Personal: unicorn, cake, cheshire, dodo, tweedle, redqueen, hatter…

Work: gnoll, carrion, kobold, bugbear, owlbear, hobgoblin…

The first is probably pretty obvious, but the latter less so (it’s very specific). As an extra point of clarification, my current personal laptop is called gryphon, and that’s not ambiguous.

Answer:

The personal machine are characters from Alice's Adventure's Underground and Through the Looking Glass, as befits this the theme of this post. The work ones are a bit more subtle; they're Dungeons and Dragons monsters, but specifically from the 1983 Basic Set (which includes the classic dungeon-dwelling monsters like Carrion Crawlers). "Gryphon", being an outdoor creature, doesn't appear until the Expert Set, and so doesn't clash with the Alice character.

A Change of Host

2024-11-01T00:00:00+00:00

A long while ago, when I first moved this domain to its own server¹, I went with ByteMark, on the basis of recommendations from a few people I knew and who’s opinion I trusted. This trust turned out to be well-founded, and I was a happy customer for a long while.

However, in 2018, they were acquired by IOMart. This was uneventful at first, but then prices started to creep up, and I started to hear grumblings from other customers about the service going downhill. However, I didn’t hit any problems myself (my needs are very simple), so inertia kept me where I was.

Things came to a head last February, which ByteMark (“An IOMart Company”) announced that they were shutting down BigV, the virtual hosting product I used, with three month’s notice. This put the wind up me and many of their other customers, and I started to look around for alternatives. Ultimately, on that occasion, they relented and kept the service going, but my confidence in them was gone. When they made a similar announcement again a few months ago, I pulled my finger out and actually started to move things.

After a brief search, I’ve gone with the strongly Cambridge-connected Mythic Beats, again on the basis of many personal recommendations. Not only has this cut my monthly bill in half, but I’ve so far been impressed with the service, the support, and the general ease with getting everything set up. As of this evening, all of my web, mail and DNS presence has been migrated over to a brand-new virtual server, and I can wind down the old one.

I’ve also used the opportunity to revisit and modernise my setup (some of the configuration was literally two decades old; time tested, but due a refresh). I’ll be following up with some more posts over the next few weeks, going over some of the highlights of what’s changed. Overall, though, it was a very straightforward process, and my only regret was not doing it sooner.

Update — Posts about the move:

I think this was a few years in, having used a shared host previously, but I can’t recall for certain, or find any certain evidence. [back]