rob.rho.org.uk

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.

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.

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.

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

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.