Grimmoire

00019-environment

I’ve taken the weekend to really chill out (partly hangover enforced on Saturday) and it’s worked out well, because I’ve been feeling really chill and I’ve also just completely revamped my desktop environment by building and installing niri.

Core to understanding my rationale in all of this is that I’m using my MNT Pocket Reform which has a small screen, and I’m very much geared toward avoiding using a pointing device, especially since I built the Pocket Deck prototype which I’ve totally failed to write about yet:

I’m now using a sizeably different stack that feels like it’s honed in on what it was aiming for:

Niri as WM

I feel like this is a more spacious and (to create an awkward turn of phrase) spaceful. That is to say that I can find where I’ve put all of my shit because everything sits relative to everything else. I feel less inclined to break things into workspaces unless I feel I have dedicated workstreams going on, because I’m not going to run out of space. Focus seems easier because you can have less on your screen but edge it with some relevant context that helps you remember why you were in this window in the first place.

It all just seems to flow a little better, and it’s somehow keeping me on the keyboard better. This is actually potentially due to the fact that I’m learning a new keyboard layout and having to translate workspace numbers into keypresses is probably just meaning I break focus less, but equally I find myself spending less time clicking for icons due to the mental load of the contortions.

I think the keyboard-based application switching of other platforms just leaves me feeling like the important thing was not where I put a window but which window I selected last, requiring me to remember that which is really not the point. My mind now is keeping a good enough map, and when it doesn’t it just doesn’t take long to find out (especially if I can learn cmd+o) .

Fuzzel as an application launcher

I think I was using wofi before using the shipped Pocket Reform setup, and honestly I wasn’t much of a fan of it. Fuzzel is fast and looks nice with just a couple of colour changes.

It’s more compact which is nice.

Alacritty as terminal

I’d previously been using foot and that was fine, but I’d found with the new WM I really wanted to consider not using a completely integrated multiplexer that meant I was always using a mixed paradigm and often causing friction, but I didn’t want to lose the vim-style copy mode. Well Alacritty supports this well enough for the features I need and allowed me to duplicate the behaviour I’d set up here in tmux, and I happen to be using it on my work Mac too for reasons I can’t really remember so this seemed like a portable solution.

It doesn’t answer the question of persistence (i.e. I’d like to excise it entirely if I can) so I’m looking at shpool right now, I just want to figure out how I can integrate into Alacritty window titles such that I can duplicate terminals in both ssh connection and current directory from a keybinding to the window manager.

I haven’t done that bit yet.

The other thing I apparently still need to do is fix up my keybindings a little because I’ve mapped return to effectively yank text and drop out of copy mode, which means I don’t have a way of completing a text search without dropping out of copy mode! I’m sure I’ll get there.

The same waybar config and widgets

If it ain’t broke etc… I might make this smaller but I really like what MNT shipped. Before I found that I would sometimes click the application icons to switch because my mental map of which window was on which desktop was shot, now I find that I just use it to keep track of how many of which window I have open which typically has me cleaning up and reusing open terminals a lot better than when I was using tmux. This was something of an unexpected side-effect!

Stuff along the way

In the end I also set up a new color scheme for neovim (with a patch to remove it’s background color) and also set up tree-sitter to have syntax highlighting for niri’s .kdl configuration format. I also exclusively used qutebrowser during all of this which meant that my hands were almost exclusively on the keyboard. It lends itself well!

There were a whole bunch of config hacks to niri and alacritty to get them how I like them, but I was really impressed with niri’s live config auto-reloading. There are a couple of implementation quirks that shine through like the choice of syntax, the mandatory splitting of command arguments and the way that special configuration is needed to clean up rendering especially when using transparent windows, but those configuration options exist as minimal implementation safe defaults - you don’t need all these bells and whistles so why put them in the code path for people who don’t need the sugar?

Up next

I’m really into implemenging this shpool integration. I’m not entirely sure I know what it’s going to look like yet… I think I could probably do something using ssh session sockets, fzf and installing shpool on all my remotes (which I can currently do for all my personal stuff).

Essentially the idea is that I should be able to spawn a shell to any of my usual remotes directly from my gui without needing to jump through any of the usual hoops in a terminal first, so e.g. press a keybinding, fuzzy match a host and session name and then jump straight into e.g. my remote weechat session as if it’s native. This is obviously pretty trivial to do with a bit of shell, but the real magic piece I want is to be able to have a keybinding for spawining a new session on the same host as the currently selected windows, which involves fucking around with alacritty window titles.

I do wonder if I can figure out an implementation I can ship as part of my work homedir config though… The issue I face whenever I remove a bunch of the friction from my personal setup is that it the exacerbates the issue of using my work macbook - coercing macOS into doing user interface stuff that it thinks you don’t need is straight up irritating and always leaves unhammered nails that you snag yourself on.

00018-retrofit

Sat Oct 12 17:55:45 2024 +0100

So here, I did a thing the other day.

I have an old Tandy 1400LT (as opposed to what, a new one?) which is in really good condition bar a couple of things - no battery, and no DC power supply. I’ve previously had it running with a benchtop power supply hooked up to the battery terminals, but that pretty much restricts where I can use it and more critically takes up my benchtop power supply.

With a lot of focus in the MNT Pocket Reform community of late on the USB-C PD functionality of the sysctl, this got me to thinking - surely there’s a way of just doing the power negotiation to get a fixed DC power supply. Welp it turns out there’s a really cheap and simple way of doing that in the Adafruit HUSB238.

This is a really simple install. You get the thing, you solder on the battery terminals, cut the traces for the default supply (5V, 1A) then bridge the pads for the supply you actually want (in my case 15V, 2A) and hook that bad boy up.

Of course, it being simple meant I had a couple of minor difficulties. Firstly, it would only negotiate 15V once I actually bridged the pads for 2A despite open meaning 3A (and in theory the device should be able to draw what it wants?). I think this might be because the supply I was using was only 45W and the default voltage was just over 5V so I guess it was trying to draw over 45W? Thing was I also tried it on a 100W supply and it failed more differentlier than that. Whatever, got it working. The second issue I had was when I finally figured this out I still wasn’t getting a 15V measurement because I’d left the multimeter on continuity mode.

Go figure.

00017-pocket-reform-lid-detection

Sun Sep 15 18:37:37 2024 +0000

Preamble

I have an MNT Pocket Reform which I’ve already opened up several times for various purposes (adding extra thermal pads to improve wifi reception, mucking about with alternative aerials, unbricking my system controller from bad firmware flashes). I’ve changed the keyboard layout and tested firmware improvements for the system controller (hence the aformentioned bricking) and even did some of the early work on packaging up the offline version of the manual. In a couple of months I’ll have it open to replace the SoM with an RK3855, at which point it’ll be my MNT Pocket Rocket.

As you can imagine, the machine is living up to the dream for me.

The idea

Today I’ve had it open for what I feel is the first innovative hack (albeit an incomplete and fairly rudimentary one), which is to add lid-closed detection by way of 2 Adafruit LIS3DH triple axis accelerometer modules.

The Pocket has a qwiic connector on the motherboard that allows you to connect (and daisy-chain) i2c peripherals to the RP2040, and there was some talk on the forums of wanting to be able to do closed lid detection and this struck me as the easy way of doing it if you’re the mechanical engineering equivalent of my dog trying to open a door that’s already slightly ajar - too stupid. The other advantage of this approach is that instead of just having a single purpose switch, you can subsequently use the sensors for detecting rotation and re-orienting the screen (for instance if you want to read content off of the pocket as if it’s a book - which I do want to do!) or just ridiculous bullshit like shaking it to turn it on (possible due to the fact it connects to the sysctl and not the SoM). Allegedly the sensors support a double-tap gesture too which might be fun to play around with in the future.

Anyway…

The basic concept here is that if you have 2 accelerometers, one in the top half and one in the bottom and they’re in more or less the same orientation in relation to their respective halves, when they both read roughly the same values then you know that they’re parallel to each other and thus the lid is shut.

What I’ve actually done

I’ll pony up here and admit that I’ve not actually done that yet because it looks (and I’ve been too lazy this evening to verify) that there’s not really enough space in the hinges to run another cable, and certainly not without having to crimp my own qwiic connector which ew no. I’ve basically just done the PoC in the top half, so I can detect when the lid is closed and it’s on a flat surface.

After a while mucking about establishing which part of the machine the qwiic was connected to (reading comprehension isn’t my strong suit when I’m trying to skip to the end; this is totally in the manual), I jumped into the system controller code and immediately found the unused i2c_scan function which I dilligently added in just before the main loop as this enumerates all i2c devices and prints them out on a pretty little 2D table! I immediately bricked my sysctl (again) because it turns out I never initialised the tinyusb dependency for the firmware, so after rescuing that I decided to give up on being an idiot who can’t read and got it working properly.

The system controller helpfully has its USB UART connected such that you can just sudo tio /dev/ttyACM0 and I was greeted with (amongst other output):

I2C Scan
   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
00 .  .  .  .  .  .  .  .  .  .  .  @  .  .  .  .
10 .  .  .  .  .  .  .  .  T  .  .  .  .  .  .  .
20 .  .  @  .  .  .  .  .  .  .  .  .  .  .  .  .
30 .  .  .  .  .  .  @  .  .  .  .  .  .  .  .  .
40 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
50 .  .  .  .  .  .  .  .  .  .  .  .  @  .  .  .
60 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
70 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .

… well that’s not technically true, the T was an @ but I’ve marked it here to show the address that was not present when I unplugged the module. This gave me the address that is, in fact, clearly written on the datasheet. I only learn the hard way though. Each module has a couple of pads that you can bridge to modify 1 bit of the address so that you can safely daisy-chain 2 of them and still address them on the same bus.

So, with the device enumerated I went on to try to find code examples for the RP2040 and what do you know, there was a code example for this peripheral on the upstream repos for the pico. This is part of the genius of using the RP2040 as the system controller - it’s absolutely ubiquitous in the hobbyist scene so there are plenty of libraries, examples and prior art out there.

I chopped the various bits of example code into sysctl.c in the sysctl’s firmware and after a broken build I fixed the i2c’s pin numbers (thanks schematic!), putting the read and print functions at the beginning of the main loop, built and flashed and it started spamming the accelerometer readings!

I’ve updated the code to have its own counter so it’s a little more… sedate now, giving a reading once every couple of seconds:

# [accel1]: 0.024g,0.924g,-0.384g

With that done, I needed to get the readings from the sysctl onto the host. Like I say, we have /dev/ttyACM0 for that, but using this gains exclusive control over it. I’m under the impression that you can either use ptys or some ioctl on the tty([^1]), but I happened to see in the manpage for tio that it supports a -S option which additionally listens on a socket. This is a nice touch as far as I’m concerned because it means that we’ll be able to put together a systemd socket-activated unit for multiplexing out access for any additonal i2c peripheral we might want to add when we get round to it.

So with that problem (in theory) solved, I’m keen to skip to the end because proof-of-concept or GTFO. Here, see the dirty shit I bestow on the world every time I do a PoC (split over multiple lines for readability - I don’t even do that I am such a trash goblin):

sudo socat - UNIX-CONNECT:$HOME/sysctl.sock \
| stdbuf -o0 awk -F, '/accel1/ { print substr($2, 1, length($2)-1) }' \
| while read n; do \
  [ $(echo "$n < -0.1" | bc -l) -eq 1 ] && echo open || echo closed; \
done

Which duly tells us when the lid is angled a sufficiently small deviation from horizontal (or I suppose swung around or something). This particular invocation will only work if you place the module in the same orientation as mine.

I’ve now expanded this a little to:

sudo socat - UNIX-CONNECT:$HOME/sysctl.sock \
| stdbuf -o0 awk -F, '/accel1/ { print substr($2, 1, length($2)-1) }' \
| while read n; do \
  [ $(echo "$n < -0.1" | bc -l) -eq 1 ] \
    && (echo open && swaymsg "output * dpms on") \
    || (echo "closed" && swaymsg "output * dpms off"); \
done

Which will dutifully turn my display off and on again as in this shitty gif (the delay is long because I had the readout frequency set too low):

There’s a better quality version of the video on imgur should you care :)

What still needs doing

So, next steps:

Fabricate or otherwise modify a version of the OLED module (which happens to be i2c) and daisy-chain a qwiic connector off the other side to provide a port in the lower half without having to run a cable, as suggested by minute (Lukas Hartmann)
Create the aforementioned systemd unit to fire up the tty multiplexer (or probably more likely find the correct ioctls or whatever is more intelligent than this)
Have a unit that tails the log and activates the appropriate power state that’s not an unholy bash one-liner.
Probably refactor the code to only build in the LIS3DH code if a compiler flag is supplied and to also check at runtime if the device is even there before running any related code (effectively making the accelerometer safe to unplug even with modified firmware). And not violate any licenses.

In no particular order.

The code

Anyway, my work-in-progress branch for this is here and the commit at the time of writing is f9bfefaa662b98dae961ef7f9f72f352ce655612 - if you want to follow in my footsteps I would very strongly advise you to be familiar with manually flashing the sysctl from another machine using the internal USB-C port and to not place any faith in any C I’ve been near.

([^1]: Okay so I looked in to this and it appears that tio is setting the ioctls for exclusive control whereas socat won’t do this for you automagically and if you use 2 different socat instances on the same device you get half of the output on each… So I’m sticking with my tio-with-a-socket option for now.)

00016-flaptack-mcus

Wed Jan 10 18:12:44 2024 +0000

This post is from waaaaay back in the first COVID-19 lockdown, and I never got round to converting it from .org format and actually posting it but I’m starting to take a look at doing something with what I discovered (possibly making a Flipper Zero zigbee sniffing module) so I’m going to get on and publish this now.

The biggest problem you might have when pursuing your own unique brand of technological freedom is that you might end up going deeper on it than you thought you would, and you’ll learn a whole shitload but not actually produce anything.

So obviously in pursuit of having my own brand of smart-home sans the completely unnecessary yet somehow synonymous data-mining, I’ve finally managed to install a fork of Micropython on a smart switch and its only taken me FUCKING HOURS.

The impotent rage of a man who choses his own problems (like wanting to be able to control the lights from magic rituals).

In all seriousness though, in this one I got to do the following for the first time: - Debug with gdb over the J-Link - Built and flashed Micropython - Hacked code on to something not explicitly designed for it - Use vendor SVD files to get easy access to peripherals - Write a gdb python plugin - Used the hardfault registers to diagnose a problem - Patched memset

A different DIY

Ikea have their own range of smart-home kit, called Tradfri. It’s super cheap, it doesn’t appear to phone home unnecessarily according to more dilligent people, and most importantly, others have already hacked on it and shown that things like UART and SWD are easily accessed.

One of the projects that I quickly found and dove into was Trammell Hudson’s [[https://trmm.net/Ikea][Ikea hacking lightening talk]] along with his fork of Micropython for the SiliconLabs EFR32 and partially implemented Zigbee stack.

My plan here was to buy one of the super cheap smart switches along with a couple of the peripherals (a plug and a bulb) and to try to hack the switch so that it could be wired up over serial to a raspberry pi to send instructions over Zigbee to the peripherals, thus enabling me to write my own HTTP endpoint to have complete control over the devices without them having to go near the internet (or without me having to install and app).

I’m increasingly under the impression that it’s a pretty specious assumption to think it could all Just Work like this within any reasonable timescale, but as you’ll see I have at least learned a lot.

Debugging

Getting set up was pretty easy. Using Trammell’s photos and instructions, I quickly: - got everything set up and the firmware built - managed to get a pretty neat setup whereby I was using an FTDI232 to not only interact with the thing over serial, but also to sub out the coin cell and supply 3.3V to the MCU. - Hooked up my J-Link EDU Mini running a gdb server - Loaded up the file, set up a breakpoint for the HardFault_Handler function - Flashed the code and reset the MCU…

Aaaaand much to my surprise we pretty much instantly hit the HardFault_Handler breakpoint.

This lead to me googling and almost instantly finding [[https://interrupt.memfault.com/blog/cortex-m-fault-debug][this fantastic article on debugging hardfaults on Cortex-M devices]]. It teaches you all about what peripherals are available by default on a Cortex-M which you can use to find out why your code failed.

Python helpers

I spent quite some time trying to figure out why the svd files that give the hex addresses for the peripherals some slightly more friendly names and convenience functions didn’t seem to have the CFSR register that I needed to debug - turns out that most vendors don’t include the core ARM peripherals in their machine-readable definitions, and more infuriatingly ARM won’t provide these either.

To save myself some mental cycles I quickly threw together the following based on some simple examples online:

BFSR_ADDR = "0xE000ed29"
BFSR_LEN = "b"
BFSR_BITS = [
    "IBUSERR",
    "PRECISERR",
    "IMPRECISERR",
    "UNSTKERR",
    "STKERR",
    "LSPERR",
    "Reserved",
    "BFARVALID"
    ]

class CFSR(gdb.Command):
    def __init__(self):
        gdb.Command.__init__(self, "cfsr", gdb.COMMAND_DATA)

    def _get_bits(self, address, length):
        bits = [bit for bit
                in gdb.execute(
                    f"x/{length}t {address}", True, True
                ).split("\t")[1].strip()]
        bits.reverse()
        return bits

    def invoke(self, args, from_tty):
        cmd = str(args).split(" ")
        if cmd[0] == "bfsr":
            bits = self._get_bits(BFSR_ADDR, BFSR_LEN)
            for i in range(len(bits)):
                gdb.write(f"{BFSR_BITS[i]}: {bits[i]}\n")
                gdb.flush()
        return

if __name__ == "__main__":
    CFSR()

I’d already determined by figuring this stuff out manually that the BFSR register contained the information I needed, and I just needed a more intelligible way to be able to view the output without getting into the weeds of a full implementation:

(gdb) c
Continuing.

Breakpoint 3, HardFault_Handler () at main.c:236
236             uart_str("!!!!!\\r\\n");
(gdb) cfsr bfsr
IBUSERR: 0
PRECISERR: 1
IMPRECISERR: 0
UNSTKERR: 0
STKERR: 1
LSPERR: 0
Reserved: 0
BFARVALID: 1

Looking for the error

This roughly translates to: - PRECISERR :: We know exactly which instruction caused the hardfault - STKERR :: It was probably access to invalid memory - BFARVALID :: The BFAR peripheral contains the memory address that caused the problem

This was pretty helpful because checking an actual backtrace appeared to be of little use - it didn’t seem to make sense.

The address in BFAR was just below the stack at the top of ROM, so this was a pretty good smoking gun, and matched almost exactly the example given in the article.

By setting a watchpoint on memory just above the bottom of the stack, I was able to see the following:

...
#18 0x00015804 in memset (s=0x21000f7c, c=c@entry=0,
    n=n@entry=132) at ../../lib/libc/string0.c:86
#19 0x00015804 in memset (s=0x21000f7c, c=c@entry=0,
    n=n@entry=132) at ../../lib/libc/string0.c:86
#20 0x00015804 in memset (s=0x21000f7c, c=<optimized out>, n=132)

    at ../../lib/libc/string0.c:86
#21 0x0001e742 in RADIO_SeqInit ()
#22 0x0001f8bc in GENERIC_PHY_RACConfig ()
#23 0x0001f900 in GENERIC_PHY_Init ()
#24 0x0001d24c in RFHAL_Init ()
#25 0x0001bc8c in RAILCore_Init ()
#26 0x00014efe in radio_init () at radio.c:347
#27 radio_init () at radio.c:317
#28 0x000145c4 in main (argc=<optimized out>,

    argv=<optimized out>) at main.c:92

(gdb)

This is pretty frustrating because the problem appears to be right in the middle of a binary blob, and my reverse-engineering skills aren’t up to much, but notably in stepping through from that point, the memset frames on the stack just keep on iterating upward.

I emailed Trammell about this and he said that he’d occasionally seen similar but not gone to deep on the debugging (which, quite frankly, made me feel like I was doing a good job), but helpfully asked if I’d tried just commenting the radio code out.

Not just the radio

Trying this out it transpires that even on hitting the gc_init code (setting up the heap for use as garbage collected memory for Micropython, or so I assume) it shits the bed at memset again.

Reading the implementation and not being particularly au fait with scarce-resource optimizations I didn’t really know what to make of this:

void *memset(void *s, int c, size_t n) {
    if (c == 0 && ((uintptr_t)s & 3) == 0) {
        // aligned store of 0
        uint32_t *s32 = s;
        for (size_t i = n >> 2; i > 0; i--) {
            *s32++ = 0;
        }
        if (n & 2) {
            *((uint16_t*)s32) = 0;
            s32 = (uint32_t*)((uint16_t*)s32 + 1);
        }
        if (n & 1) {
            *((uint8_t*)s32) = 0;
        }
    } else {
        uint8_t *s2 = s;
        for (; n > 0; n--) {
            *s2++ = c;
        }
    }
    return s;
}

Honestly? My lockdown brain can’t comprehend that, and certainly not how it seemed to result in recursion behaviour. This was crossing a couple of areas of expertise and none of them dovetail with mine - however git log -p -- lib/libc/string0.c was very kind to me and let me know the current implementation was a performance optimization.

That meant there was an earlier implementation I could check out!

I copied the old code out from before that commit:

void *memset(void *s, int c, size_t n) {
    uint8_t *s2 = s;
    for (; n > 0; n--) {
        *s2++ = c;
    }
    return s;
}

YEAH BOIIIII I’m smart enough to understand that!

I uncommented the radio code in order to see if it all still caught fire and hey presto, not only did it not hardfault but I got a REPL over the serial console!

But WHY?

Honestly fucked if I know. the way that it would jump back in the memset it feels like it was perhaps accidentally rewriting the stack pointer over and over again…

I should probably debug this and see if it’s worth trying to fix properly in the original implementation, but I also should actually try to do the thing I originally set out to do.

I’ll update here when I decide which to do - I’m already taking time out from that to write it all down!

00015-speculative-friction

Tue Sep 26 10:23:46 2023 +0000

Recently I came across (for the second time) the text editor bitters which is essentially a lo-fi love letter to the Canon Cat. I’d seen this before, having some time ago watched a video about the Canon Cat and falling in love with the simplicity and humanistic view of human/computer interaction.

I gave it a try on my work macbook the other day, this being the sort of thing that I do for a break. Because in my convoluted internal logic, obviously, your RSI/eye-strain/mental fatigue meters all reset when you switch between work and “leisure problem solving”.

Anyway, installed sdl and build the thing and off we went. I quickly realised, however, that to have a really satisfying writing experience I would need to adapt my keyboard to make the leap keys accessible and having a split ortholinear keyboard (in the crkbd or “corne”) I would also have to make so that this new layout is highly symmetrical.

So fast forward to last night where, after work, I had the mental energies left to consider Doing Something Productive, and one of the things which I’ve been wanting to do some more is write (as evidenced), in part due to having recently picked up a copy of Abolition Science Fiction and really enjoying the succinctness of the short story format for throwing out ideas without the deep-seated need to contextualise and explain. Luckily, the book has a set of writing prompts and exercises in the back!

So, I thought to myself, maybe now is a good time to give that a go! Let me just reprogram my keyboard layout quickly…

And this, dear reader, is how my life proceeds. Because some time ago I accidentally ripped off the micro-USB socket on the left-hand side of my keyboard and had to reprogram the right side to be the master. What I didn’t factor in when I did this (and subsequently reprogrammed the layout on the right side to replace backspace with del so that I could essentially SIGINT on a fresh Plan 9 install) was that I could no longer program the left side, which would become an issue as soon as I tried to flash the right side with a more recent firmware.

So yeah, last night in an effort to start writing again, I nearly bricked my keyboard before realising that I still had the old working checkout of the old firmware build which with some massaging (it upsets more recent versions of avr-gcc and avr-ld without some flags and modifications, notably one compiler issue requiring --param=min-pagesize=0 and one linker issue requiring that I reorder some definitions.

I managed to go to bed with the resumption of an equitable keyboard at the cost of a couple of hours work.

I’ll bring my work Corne home before I try this again.

And this marks a repeating frustration in my life - to achieve a frictionless experience requires a lot of speculative friction. But I think that’s probably just the kind of person I am and this was a necessary obstacle for me to overcome. At least I’m writing now!

00014-lc3

Fri Sep 16 11:09:55 2022 +0100

Hello world

I’ve been working on a virtual machine under 9front implementing the LC3 educational ISA. This has been a lot of fun, and I realise that probably sounds weird to a bunch of people who did CompSci at university and were made to do this sort of thing. In that sense I’m like a mature student - I’m actually doing it because I care.

Initially I started out when I was on a 7 week trip through Asia (I know, I never update this thing, but then nobody reads it either). I was in Kuala Lumpur and taking a much needed rest, and for some reason that I can’t quite remember I just decided to search “how to write a virtual machine” and a blog post came up which essentially lined up the problem of how you’d go about implementing LC3. So I just started.

And I continued in Nepal, where I finished off the majority of the VM and a rudimentary assembler and patched vexed hex editor for binary input to help with my hand-hacked test machine code.

And I continued on a beach in Thailand, where I wrote the beginnings of an assembler.

Yesterday I reached an important milestone - I was able to assemble and run the following program:

    .ORIG   x3000
    NOP
    ADD R2,R2,x6    ; we need 6 loops to get to 'h'
    NOT R2,R2       ; we want to be able to subtract this number so we'll 2's complements it
    ADD R2,R2,x1
LOOPH
  ADD   R0,R0,xf
    ADD R1,R1,x1
    ADD R3,R1,R2    ; compare if we're at 6 loops yet
    BRn LOOPH
    ADD R0,R0,xe
    OUT
E   .FILL   x65
L   .FILL   x6c
O   .FILL   x6f
    LD  R0,E
    OUT
    LD  R0,L
    OUT
    OUT
    LD  R0,O
    OUT
    .BLKW   x5
    LEA R0,WRLD
    PUTSP
    HALT
WRLD
  .STRINGZ  x20776f726c64210a
    .END

Which runs thusly:

cpu% lc3/lc3 -f out.hex
hello world!
Program complete, exiting

I think it’s quite a fun “hello world” because I wrote it as I was implementing features of the assembler…

Raw data directives

Up until the first OUT (which was a TRAP 0x21 at the time) I only just had assembling into a binary format working, with none of the raw data loading directives so I had to ADD the largest positive value supported by ADD’s immediate mode (which only supports a 5 bit signed operand) 6 times and then add the remainder to get to 0x68 or h.

To get the rest of ello I then implemented .FILL and (now that I think about it) just let the machine blast through trying to interpret those instructions (I should probalby fix that hahah), but this means that we’re then able to LD those memory locations into R0 which then means we can use the OUT trap to print each one in turn.

Then we have .BLKW which I didn’t have much use for in this program but it was easy to implement after .FILL so my implementation also initializes to 0x0 which maps to NOP (or more strictly, unconditional branch to PC).

Finally, .STRINGZ. As you can see, I’ve not implemented any data literals other than hex yet, so I still have string literals and decimal to implement but I don’t need those to demo that my VM is working.

Future work

I have some plans for this VM which I’m not going to talk about, because I’ve found in my life that talking about an idea to people often exhausts the need to actually follow through on it - needless to say it’s weird dumb bullshit like you’d expect from me.

The plans which I am going to talk about here are the 9p debugging features I’d like to implement.

Essentially, I’d like to write a filesystem which has something like the following layout:

reg/
  pc
  cond
  r0
  r1
  r2
  r3
  r4
  r5
  r6
mem/
  full
  0/
    0/
      0/
        0
        1
        ...
    1/
    ...
  1/
  2/
  3/
  ...
clk
cons

The idea here is that you can read and update the state of any given memory address or register at any point, and you can step the clock simply by reading clk. You can follow the program along by reading reg/pc and then reading the corresponding address.

In fact, beyond that I doubt it would be that hard to also have a disasm/ tree as well which will allow you to follow along with a disassembled version of the program.

This then means that your debugger is a simple filesystem API which you can then instrument and script around using rc, awk, whatever. In that sense, I’m kind of surprised that acid was never designed in this way, because I’d say one of the huge advantages of Plan 9 is that you don’t have to learn someone’s implementation of a given API or language when you can simply explore a filesystem and write tools to manipulate it.

Anyway, that’s what I’ve been up to.

00013-emf

Wed Jun 29 10:08:39 2022 +0100

This last weekend I spoke at EMF on “Computational Alchemy”. Thtalk was really well received and despite the timings not going quite how I intended, I’m really quite happy with the result, along with some of the other things I saw and did.

Cultural Context

Generally feedback was really positive, including the constructive criticism: I was approached afterwards by someone who had converted to Judaism and very bravely and gently suggested that I might want to talk more about the differences between Kabbalah and Hermetic Qabalah, particularly given the history of Christian Cabala (a.k.a. Kabbalah with Jesus hamfistedly bolted on to Tiphereth) in coercions to convert Jews to Christianity. Which is to say that forms of syncretized Kabbalah have been used in an anti-semetic way.

I found this to be very fair criticism personally. I’d wanted to make more of a point of separating out Hermetic Qabalah and Kabbalah itself but had kind of screwed up the timings so had to rush past it. I wasn’t previously aware of the cosmology having been used as a tool of this sort of behaviour, but I was aware of the forced conversion of Jews in Spain at least from having read Owen Davies' “Grimoires”.

I feel that if you’re going to engage in syncretism then you need to be aware of how some forms of syncretism are a subversion more than they are a celebration, and when presenting that to an audience this point needs to be made. I at least managed to make it clear that my iterations are iterations upon an interation which does not accurately reflect the source material, and that’s fundamentally part of the exploration in it’s own right.

Computer Church

There was an installation made from several old computers and a Microsoft Kinect in a shipping container which reactively played music and visuals based on movements it detected. Now personally I preferred it when it didn’t detect movement, because one of the first things I said to the artist was “It’s so nice to see some computers enjoying themselves without people ruining it”. The music as well was ambient, evocative and I suppose a little bit religious in a sense, and walking in to the place I was washed over with a sense of calm and oneness.

So I think I want to do an installation or unofficial event next time: Computer Mass. With some old computers as set dressing (or an altar if you like), I’d like to come up with a secular religious ceremony that presents the iconography and lore of computing, kind of in reference to the comfort that we all find in it. I made allusions to this on social media and I think people are up for it, which would be great!

Part of this is in response to the general state of community contribution as well. As part of the Scottish Consulate village where we had someone cooking up deep fried buckfast and giving it away, the Scottish Drinking Experience, contributions to WhiskeyLeaks and essentially running a DnB night every evening out of our (quite frankly incredibly shonky) tent as DJ’d by some other members of the community, it was easy to see how much that contribution matters but also where it’s lacking. I like the idea of providing some real fringe stuff that might not make it in the grand scheme of officially sanctioned events but would be pretty comfortable outside of that.

Anyway, definitely want to do some more Weird Shit and I think exploring the shared cultural heritage of computing and acknowledging the impact of religious experience in a trans-faith kind of way would be a really fun thing to do.

00012-qabalah-space-program

Thu May 26 11:30:51 2022 +0100

The thing is, TarotFS is not the most out-there piece of software that I’ve worked on under the guise ocyber-occultism and in fact is first real foray into what I like to call “Computational Alchemy” is called qsp which is short for Qabalah Space Program.

The name is obviously a riff on a popular rocket science simulation game, at least in part because I’m hacking together random components with the nominal goal of exploring some extra-dimensional space and I have absolutely no idea what I’m doing. But let’s focus in on the “Qabalah” part…

Hermetic Qabalah

WARNING: Do your own research! I’m oversimplifying and not heavily fact checking here for the sake of some narrative context. It did not happen exactly like this.

To cut a long story short, Qabalah is pretty much a second order descendent of the school of Jewish mysticism, Kabbalah. Something like this:

Kabbalah -> Christian Cabalah -> Hermetic Qabalah

The OG Kabbalah is just straight up fantastic as far as I’m concerned. To summarise (my understanding at least), it’s essentially a system in which God speaking the world into existence actually functioned, so that the creative act ex nihilo is described by mechanism of the numbers 1-10 (represented by the 10 Sephiroth, or “emanations”) and the 22 letters of the Hebrew alphabet and their particular categorization (3 mothers, 7 doubles, 12 simples) represented by the paths between the emanations. Systematically it attempts to describe all of the features of both the macrocosm and the microcosm through a series of separations from the godhead, creating dimensionality, movement, birth, death, so on and so forth. As complicated as that sounds, it’s a real simplification. If you want to lose hours of your life to a deeply complex systematization of reality and a human as a reflection of that, you know what to start reading about.

As you can imagine, due to its lineage Christian mysticism at some point wanted a piece of the action. Also unsurprisingly, it involved trying to jam Jesus into the scheme, much as you might try to jam too many syllables into some song lyrics. I don’t have much to say about this because a) I don’t know too much about it and b) Christian syncretism to my untrained eye is like a box mix that says “JUST ADD JESUS”.

Anyway, somewhat unsurprisingly with these concepts being expounded on by the likes of Agrippa in the 16th century, it was somewhat inevitable that in the 19th century magical revival that people like and adjacent to The Hermetic Order of the Golden Dawn were going to pick up on the concept and run with it. Around this sort of time, Eliphas Levi for instance was the first to attribute the Major Arcana of the Tarot to the 22 letters of the Hebrew alphabet, creating a direct translation between the two systems. Moves like this have triggered using the 32 paths of the Tree of Life (10 emanations, 22 links between them) to be used as a central pivot of equivalences in modern occultism, and if you’re tuned into these things (or, hilariously, the right kind of anime) you may recognize at least one graphical formulation of the system, the Etz Chaim or Tree of Life:

This is, in of its own right, fascinating. We’re talking about a system of Jewish mysticism that was syncretic of the creation myth, language, mathematics and medieval terminology being increasingly built upon to become of “profound” meaning to esotericism going forward.

To my mind, there’s an exercise in credulity to be done here.

Computational Alchemy

Allow me to change subject for a moment - don’t worry, I’ll bring it back round.

Isaac Newton famously discovered calculus as a collateral offshoot of his work in alchemy, toward the Magnum Opus of transmuting gold and of creating the Philosopher’s Stone. Here we have an example of credulous engagement with a historical system claiming antiquity and scientific validity producing something world-changing, or at least demonstrably incredibly profound and useful.

Now profound and useful are all well and good if you’re in to productivity, but personally I’m productive enough in my day job. I’ll settle for “pursue an arbitrary goal and see what weird shit falls out”, and I think that’s kind of what I mean by Computational Alchemy - it’s the “fuck around and find out” answer to the scientific method. Where the scientific method requires a hypothesis to disprove in order to not meander off into the tall grass, I’m treating the meander into the tall grass to be the edifying bit - where will it take me? Who knows? Who the fuck even cares?

Qabalah Space Program

Which brings us to what I actually did.

The first thing to note is that I’ve named it for Hermetic Qabalah, on the basis that I want it to be clear that this is very much a syncretic extension of a syncretic system, and that I’m not about to attempt to retcon my discoveries onto a system that stands in its own place and time and culture. 19th century Hermeticism, however, is asking for it.

So what exactly are we going to try to achieve here? Well when I was at university I did a masters' project on simulating electron energy loss spectroscopy on transition metal silicides, and part of prepping data for that was to compose a structurally correct formation of atoms and then running it through several iterations to essentially seek the lowest energy configuration, which is to say to find the natural configuration in which all of the forces are resolved to as close to a stable state as makes no odds.

So after reading some of Chaos by James Gleick, one of the many books that I’m still half way through, I began to look at the Tree of Life from the lens of a physics many-body problem - if I resolved the forces along the paths, what would the resulting configuration look like? What if I change the resting lengths and coefficients of restitution of all the paths? What if I map it into 3D space and join Kether to Malkuth (something you would reasonably do based on an understanding of the Four Worlds scheme in Kabbalah) and then run the simulation? What will this tell me about the universe? More importantly, what hilarious side-effects will fall out of the pursuit?

The tl;dr is that I’ve essentially implemented a scheme for doing this on 9front using libdraw for graphical rendering and composing configurations, using ndb (yes the network configuration database format) as a graph database, and a whole lot of farting about in acid looking for memory management bugs when my actual programming logic just sucks.

This post is a bit long in the tooth already though, so let’s leave the implementation and some early results for next time!

00011-tarotfs-from-grimm-labs

Fri May 13 10:59:24 2022 +0100

TarotFS from Grimm Labs

or Why I Stopped Worrying and Wrote A Divination System Considered Harmful

Trope subtitles are the worst.

In this post I’ll be talking about TarotFS from Grimm Labs, my divination system filesystem for Plan 9. In part, I’m using this as an exercise to figure out what parts are going to make the cut for my EMFcamp talk.

Divination systems

I’ll hopefully talk in depth about this at another time in another place, but the tl;dr is that my first practical foray into occultism was through divination systems. I can’t remember if I got a tarot deck first (thanks tj!) or a set of Elder Futhark runes (thanks Joey and Mae!), but the value was pretty easy to see from the point of view of a person struggling so much with their emotional and mental health during COVID. I was able to pick out images at random and see how they resonated with me, and what the historical symbolism was around these archetypes that could be plumbed further to find more interpretations and develop my own associations.

Looking back it makes a lot of sense - people think in terms of narratives, allegories and symbols, so having these arrayed out in front of you, drawn at random such as they’re “presented by the universe” (a trope deeply embedded in culture and religion) strikes a chord and drives engagement with what is essentially a system for introspection and decision making with an RNG (random number generator) built in.

Where did the idea come from?

Okay, so one of my biggest projects and the one I talk about the most if you know me in person (or on IRC or on gridchat) is TarotFS. It’s really the first use case for Plan 9 from Bell Labs (or the fork 9front which I’m going to lovingly refer to as ⑨ from here on in, despite the fact that it completely fucks with vt not to use a single width character but here we are) that I had which was really an occult system. And ⑨ really suits the use-case. One of the most famous if not totally fundamental ideas behind Plan 9 is putting the Unix concept of “everything is a file” to shame, showing it as the true hyperbole that it is. In ⑨ just about everything actually is a file, and the real case-in-point here is the 9p protocol. When you access the web, you can do that using webfs using the 9p protocal bridging with HTTP. Want to make a TCP connection? Do the same. Want to access a file? You guessed it, use 9p.

So when I started playing around with ⑨, I was really interested in this concept and so I started playing with webFS and really liked how it effectively meant you could leave your HTTP transactions on disk. Around the same time, I was also reading Techniques of High Magic by Francis King and Stephen Skinner (or at least that’s how I remember it? It could be that the book’s right in front of me…) and about various divination systems including geomancy and runecasting. Tarot stood out because it’s well known in Western society as being… well… goth as fuck quite frankly, and I was in a place where archetype systems were incredibly appealing to me. Possibly more on that elsewhere or later or something.

At any rate, the mode of transaction with webfs really struck a chord:

† cd /mnt/web/
† ls
clone
ctl
† cat clone
0
† cd 0
† ls
body
ctl
parsed
postbody
† echo 'url https://grimmwa.re' > ctl
† cat parsed/url
https://grimmwa.re/† 
† 
† cat body
<html>
<head>
  <title>(((GRIMMWA.RE</title></head>
    <meta charset="UTF-8">
    ... and so on ...

The workflow goes like this: 1. “clone” a new session by reading the clone file. This will return an integer which will be the name of the directory which will be created for your session (which you can see we cd into. 2. Enter any parameters for the session into the “control” file for the session, ctl - in this case we’re entering the (somewhat necessary) url parameter. We can then verify that we entered it correctly by reading out the parsed/url file. 3. Read out the request body by reading the body file! When we do this, it looks like we’re reading a file from disk, but actually we’re dispatching the HTTP request that we’ve prepared by creating the session and telling it the URL, and this is essentially the response body!

Like I say, you have the transaction apparently “on disk” and are able to set parameters and headers and the like by writing to files and reading responses by reading them. A query and a response, all effectively encoded statefully in a way that you can sensibly manage and retrospect on.

Something twigged with me here, because it was at the intersection of ideas - I was exploring ⑨ which I was clearly going to do from a participatory viewpoint, and I was also beginning to start to understand some of the less supernatural value in divination systems, and frankly I understand by doing and I needed a distraction.

And somewhere in here is where TarotFS was born as a concept.

How does it work then?

Yes, we’re doing this in skip-to-the-end style, mostly because I didn’t make enough notes on the way so I can’t actually remember what I did and what problems I hit and why. A big warning here is that the code’s a bit of a trash fire, so I’m going to present you with a couple of things: a TarotFS session, which I’ll use to explain a high level idea of the basic usage and rationale, and a manpage which I’ll dump at the end.

Example Session

† tarot -p definitions -dkP
definitions/Smith-Waite

We launch tarotFS with a definitions directory, and descriptions (-d), keywords (-k) and paths (-P) enabled in the card output. This is pretty much the whole selection as we’ll see in a bit! Essentially these three options only do anything if you specify a definitions directory as they simply read data for the relevant card from it. TarotFS helpfully then tells you which subdirectory of definitions it’s using because I haven’t fixed that old shitty debug output yet!

† cd /mnt/tarot
† ls
clone

/mnt/tarot is the default mountpoint - not much to see here yet apart from the clone file!

† cat clone
1
deckstyle Smith-Waite
definitions_path definitions/Smith-Waite
keywords 1
description 1
orientation on

When we read the file it does what webfs does - creates a new session for us! This file actually redirects reads and writes from the ctl file from the new spread, so we could actually have cloned the session by overriding a setting with a write instead if we really knew what we were doing.

Helpfully, you can see that when I hacked in the orientation parameter recently I didn’t check my boolean convention and have instead used “off” and “on”. Some parts of tarotFS are wildly inconsistent, and for my part I will actually fix this. At some point. Maybe.

† cd 1
† ls
ctl
draw
remaining
shuffle

Other than the ctl file, it should be pretty much immediately obvious what each of these files will do if you read them!

† echo spread past present future advice > ctl
† cat ctl
1
deckstyle Smith-Waite
spread past present future advice
definitions_path definitions/Smith-Waite
keywords 1
description 1
orientation on

For the sake of showing off we’re going to specify the names of some of the cards which will be drawn. By default, the card filenames are just incrementing numbers, but these arguments will make so that we get names e.g. 1:past, 2:present and so on. Part of the advantage of this is you can’t decide on one spread and then change your mind half way through when you get a card you don’t like ;)

† cat remaining
78

78 cards in a standard Rider-Smith-Waite deck!

† cat draw
Four of Pentacles
reversed
path  definitions/Smith-Waite/Pentacles/Four/
UPRIGHT: Saving money, security, conservatism, scarcity, control.
REVERSED: Over-spending, greed, self-protection.


The Four of Pentacles shows a man sitting on a stool, beyond the
boundaries of his hometown. His arms are wrapped tightly around a coin
as if he fears he may lose it if he loosens his grip. He balances
... <SNIP> ...

So what we’re seeing here is the contents of one of the cards being drawn, containing the orientation (on by default, cards can be upright or reversed), the path of the card definition that the keywords and definition text are coming from, and then the keywords followed by the definitions.

The path is useful if you want to do things like ship the card images! It makes it simple to script a setup to view the spread graphically!

† cat remaining
77

Just in case you doubted that these are actually being drawn from a deck…

At any rate, that was a bit more verbose than we care about right now so we can toggle the descriptions and the orientations off:

† echo description > ctl
† echo orient > ctl
† cat ctl
1
deckstyle Smith-Waite
spread past present future advice
definitions_path definitions/Smith-Waite
keywords 1
description 0
orientation off

Now when we draw, we’ll just get the path and the keywords:

† cat draw
Seven of Cups
path  definitions/Smith-Waite/Cups/Seven/
UPRIGHT: Opportunities, choices, wishful thinking, illusion.
REVERSED: Alignment, personal values, overwhelmed by choices.

† cat draw
Ⅷ: Justice
path  definitions/Smith-Waite/Major/Justice/
UPRIGHT: Justice, fairness, truth, cause and effect, law
REVERSED: Unfairness, lack of accountability, dishonesty

† cat draw
ⅩⅩ: Judgement
path  definitions/Smith-Waite/Major/Judgement/
UPRIGHT: Judgement, rebirth, inner calling, absolution
REVERSED: Self-doubt, inner critic, ignoring the call

So what about the card names and the state on disk I was talking about? Well here we can see that the output can be read again by reading out the respective numbered file:

† ls
1:past
2:present
3:future
4:advice
ctl
draw
remaining
shuffle
† cat remaining
74

Features and misfeatures

A lot of this has grown organically, so there are a few warts, gotchas and implementation details:

Definitions are user-supplied because I ripped mine off from the internet so they’re not mine to redistribute
A few “deckstyles”, however, are supplied (see /lib/tarot/decks)! The default is Smith-Waite (as in the famous Rider-Waite deck, for whom Rider is a publisher and Pamela Coleman-Smith is the largely unknown artist who actually did most of the work), but we also have the Marseille deck which uses slightly different card and suit names, and also Elder-Futhark which is me showing off that actually technically you can use TarotFS to do runecasting as well:

   † tarot
   † echo deckstyle Elder-Futhark > /mnt/tarot/clone
   † cd /mnt/tarot/1
   † cat draw
   ᚺ
   reversed

Some arguments and commands are a little inconsistent or poorly documented - sorry about that!
I’ve also been working on a fun script for rendering the spread in a rio window, with a tarot cloth as a background and everything, but it requires a patched version of rio and also a patch which I’ve written for page to auto-resize the image which I’ve not gotten round to documenting yet (and this post is getting pretty long anyway!)

Future work

I’ve got a few plans here. For one, I’d like to be able to use arbitrary bitstreams as an entropy source given that none of the randomness here is used for cryptographic purposes, so it would be great to be drawing the randomness from the processes of the universe (like gridchat!). Some more work to improve the consistency of the interface and documentation would certainly be good, and I’d also like to do more work on convenience scripts for graphically rendering in Rio for example. Finally, a good default definitions source which is appropriately licensed for redistribution would also be great.

Appendix: Manpage

This needs updating! I’ve not actually added the instructions on using the orient command and a couple of other things, but fixing instead of writing is how I end up never writing things.



     TAROT(4)                                                 TAROT(4)

     NAME
          tarot - tarot card filesystem

     SYNOPSIS
          tarot [ -DdkPh ] [ -p definitions ] [ -m mtpt ]

     DESCRIPTION
          Tarotfs presents a file system interface to generating and
          interacting with tarot spreads.  Tarotfs mounts itself at
          mtpt (default /mnt/tarot).  The -D flag enables 9P debug
          prints and other debug files and -h displays the short list
          of options.

          Tarotfs also optionally supports displaying keywords and
          definitions when reading files for the drawn cards by pro-
          viding a definitions directory with the flag -p wherein the
          directory structure should follow the structure:
          Name/Suit/Card/ and contain the files keywords and
          description, both of which can be freeform text files. The
          keywords should ideally contain a short list of keywords to
          associate with both the upright and reversed configuration
          of each file. The Name/Suit/Card naming convention has the
          following restrictions:

          Name This can be any directory name, and isn't actually uti-
               lized (yet).  Currently tarotfs will just pick the
               first named pack inside the supplied definitions direc-
               tory.

          Suit and Card
               These must match exactly the form given in `suits`, and
               `major` and `minor` for each deck definition, but with
               anything preceding and including a single colon charac-
               ter stripped, and all spaces removed. For example: "I:
               The Magician" should map to "TheMagician".   Any major
               arcana cards will always map to the suit name `Major`.

          The flags -dkP enable displaying the definitions, keywords
          and definition paths when reading the card files respec-
          tively when -p is supplied.

          The top level contains the file clone, and the directory
          card_library, the latter of which contains a tree of all the
          available cards.

          Reading or writing to the clone file creates a new numbered
          subdirectory for a new tarot spread and redirects the opera-
          tion to the ctl file at the top of the directory.

          Each "spread" directory contains the files: ctl, draw,
          shuffle and remaining.

          The ctl file is used to control the various settings for the
          spread by writing commands and arguments to the file:

          spread
               Sets the names for the drawn cards in addition to their
               numbers.  Arguments are space separated.

          keywords
               Toggles whether keywords are displayed when reading
               card files

          descriptions
               Toggles whether descriptions are displayed when reading
               card files

          paths
               Toggles whether definition paths are displayed when
               reading card files

          Reading the ctl file will return the spread number (matching
          the spread's directory) on the first line. If a deck defini-
          tion was supplied, it will also print on the following lines
          the attributes deckpath,keywords,description each followed
          by a space and then the path of the deck definition and the
          booleans for whether keywords and descriptions are enabled
          for the spread respectively.

          Reading draw draws a card, reading remaining shows how many
          cards are remaining in the deck and shuffle will reshuffle
          the deck.

          If the -D option is passed on startup, there will also be
          the deck file which outputs the integer representations of
          all the cards in the deck along with their number order.
          This is currently only used for debugging purposes.

     EXAMPLE
          The following shows a simple example of cloning a new
          spread, setting the spread name and then drawing all the
          cards from the spread.

          † tarot
          † ls /mnt/tarot
          /mnt/tarot/card_library
          /mnt/tarot/clone
          † cat /mnt/tarot/clone
          1
          † cd /mnt/tarot/1
          † ls
          ctl
          draw
          remaining
          † echo spread past present future advice > ctl
          † for(i in `{seq 1 4}) cat draw
          Four of Pentacles
          upright
          Ⅱ: The High Priestess
          reversed
          King of Wands
          upright
          Seven of Cups
          reversed
          † ls
          1:past
          2:present
          3:future
          4:advice
          ctl
          draw
          remaining
          † cat remaining
          74

     SOURCE
          https://git.sr.ht/~grimmware/tarotfs

00010-magnum-opus

Tue May 3 21:06:20 2022 +0100

What’s been going on at Grimm Labs

What I’ve not shared

I’ve been away for a few days with some time to think about the division in my life between my work life and my life’s work - that is to say, what I get paid to produce and what I want to produce. Fundamentally I’m a creative person who needs to have some kind of “output” in order to feel satisfied, but it has to be something that comes from within rather than being something I’m obliged to work on by some external entity (least of all the coercion of capitalism making me do it in order to survive).

Something that’s been on my mind a lot lately is sharing what I do, and I’ve written about this before. The dumb thing that I’ve realised is that I haven’t actually written anything about what I consider to be my most important line of work, what essentially comes closest to the goal of Computational Alchemy (or “Occultism fuck-around-and-find-out but on a computer”). We’ll call this my “Magnum Opus For Now” (because lol).

So the core of my Computational Alchemy work is on the late 80s and early 90s research operating system Plan 9 from Bell Labs. Rather than go deep into the rationale here, I’m going to leave that up to a later post to try and cement my commitment to continue writing. But essentially I use a distribution called 9front which has some newer hardware support and a more active and modern community, and attempt to credulously take esoteric systems and codify them, or otherwise participate in the only way I know how: technology. So far, I’ve done work on usability hacks to customise the system to work in a way I get along with, but also produced the foundations of a set of occult software.

Body of work

Plan 9 Usability hacks

Keyboard-based text selection in the core “command prompt” interface with some other keybindings for good measure
Shell customizations for command history
Convenience hacks on the core image and document viewer
Helper scripts for connecting to 9p.zone gridchat

Plan 9 Occult software

A program for doing tattva vision meditation
A pretty fully featured tarot card filesystem that also supports runic alphabets and custom oracle decks
The beginning framework of what I like to lovingly call Qabalah Space Program, a suite of programs for visualizing, modeling and simulating the Etz Chaim (Kabbalistic Tree of Life) as a physics many-body problem (amongst other things) to see what falls out.

Other weird shit

Some code to do format conversions of astrological catalogues which I accidentally got nerd sniped on the other day and never actually finished. Not sure that I’m too committed here.

So what next?

Effectively I’m committing myself to actually writing about this work to share it with the world. TarotFS certainly deserves a deeper look, as I’ve worked on it pretty extensively and actually shared the work at a virtual conference. I’ve also submitted a talk to EMFcamp which I’m really hopeful about getting accepted, but actually writing about my work is a good way to a) prep and b) not put all my eggs in one basket. (EDIT: in between writing this and actually publishing it the talk got accepted so YAY FOR ME, but also the point still stands)

Anyway, I guess watch this space! I have an rss feed at https://grimmwa.re/blog/feed.xml that’s fully populated with the content I produce here, so add that to your feed reader if you want to follow along!

00009-magic-and-performance

Thu Mar 17 10:10:59 2022 +0000

A while ago (2020? God damn it’s been a long couple of years.) I read a book called Magic, Science, Religion and the Scope of Rationality by Stanley Jeyaraja Tambiah, which is essentially an anthropology and philosophy text on… well what you’d expect having read the title. One of my favourite points made in reference to some peak academic sass (very possibly Wittgenstein) was a rebuttal about how the beliefs were “in error” or essentially that people who carry out some of the cultural practices that we in Western culture consider to be “unenlightened” is (to put it bluntly) sourced from stupidity.

The argument goes that in cultures that perform rain dances, they only do them before the rainy season starts. Because they’re not stupid, and they don’t think that dancing makes it rain. This kind of cause-and-effect thinking is very post-rationalism, because science itself does not (in the modern era) encompass human nature enough to account for performative and participatory action.

If that didn’t make an awful lot of sense I’m not surpised, I’m a grate riter and I’ve also been mulling the idea for quite some time to make it sit right and it’s only recently settled.

Take for example a teenager playing air guitar in their bedroom along to some rock band. You wouldn’t look at that and suggest that person thinks they’re actually in the band, and they’re clearly not contributing to the music, practicing for some real-world skill or even performing for an audience… They’re simply participating through a want to somehow be involved with something of importance.

Obviously I can only speak to my experience of participatory practice, and for me it’s got a lot to do with the balance between agency and control. By writing occult software for a defunct operating system that nobody uses for profit, I am participating in a theoretical world where humanism and utility is valued over economic growth - a hobby that somewhat unsurprisingly grew out of a global pandemic in which we sacrificed lives in order to appease the invisible hand of the free market. By doing tarot every day, I pause to reflect and seek and feel like I’m receiving help from without instead of suffering on the continual treadmill of informational and social engagement.

That said I’m not great at performative ritual personally. Aside from a couple of banishing rituals to stop me from dwelling on things I can’t control I still haven’t developed that muscle of turning to participatory things in order to engage with the ebb of life rather than try to wrestle it in the direction I feel it should be going. Maybe that’s next?

00008-to-dispel

Thu Mar 10 10:24:50 2022 +0000

To Believe

I suppose that part of my journey delving into magical and religious practice is to understand the utility of belief in greasing the wheels of life (… a mixed metaphor of dubious provenance if ever I wrote one). After all, I am very much a nihilist and as the old adage goes “[if] Nothing Is True [then] Everything Is Permitted.”

One very fundamental tenet of Chaos magic and similar systems is that you can choose your belief to suit your purposes, or even more chaotically choose your belief just to see what happens. It’s very much the alchemy to religion’s science - the “fuck around and find out” of belief systems if you will.

Personally I’m not much of an adherent to the random choosing of belief, or at least not yet. Those that are prepared to precipitate “madness”, however you want to define that, clearly don’t have much to lose societally, and I’m very not in that place. I’ve invested a lot of time learning how to fit in with ~~your~~ human society, and it’s been hard won.

At any rate, I can see the wisdom of picking belief to facilitate some kind of premeditated functional purpose. It turns out that in adopting that philosophy, pretty much every attempt to adopt a belief to my own personal utility has really ended up with me shedding one instead.

To disbelieve

When you engage in the practice of reasoning about what arbitrary belief you could adopt in order to better yourself, effectively you’re examining the beliefs you already hold in order to modify them to better fit the result you want. But ultimately I’m not of the ilk to reason that my beliefs should really shape my reality - I think they change how you perceive problems, focus your time, your interactions, your mode of communication. After all, we don’t have that many IRL Disney Princesses despite Mickey’s psyops and propaganda divisions' best efforts.

So I ask myself what beliefs facilitate things like a less anxious approach to life - less dwelling on the worst that could potentally happen, less expecting the worst from people, less expectation on myself to solve everyone’s problems. What I come away with is the realization that I believe I have responsibility over those things, despite having very little agency over them.

I like to use the analogy that we have at least two worlds we have to deal with at any moment: the model of the world in our own heads that we use as an abstraction to reason, predict and generally model our interactions with the “real” world, and the physical consensus reality. A lot of satisfaction can be gained when we can converge the two (and conversely a lot of mental anguish when we can’t) and there are two ways to do this: shape expectation to reality or change the physical reality to expectation.

In looking at my own beliefs, I realised that I tend to do the latter: expecting the world to react sensibly to COVID for example and getting stressed about the human cost of it not. But I don’t have agency over that, and I realised that I was hurting myself by carrying around the belief that people should be better and more caring. The thing is they’re not, and to compound that to believe that they are is to diminish your own good qualities. Another example: pretty much every kind person I know who has suffering in their life at the moment will caveat it with “… but that’s nothing compared to what the people in Ukraine are going through.” This one grinds my gears really hard. Somehow we have created a social and moral system in which the kind of people who consider others will disregard the immediate problems of their own lives because of some perverse flavour of subjectivism in which only other people’s problems count. I’m looking at you here Western theology… At any rate, the belief here serves nobody. Are you empowered to solve the problems in Ukraine? I mean sure you can try to help but the problems there are caused by much more powerful people who want us to think that everyone has their part to play because “democracy”. On the flip side, for better or worse we live in our own personal problems and are at least in some way empowered to fix them, and to do so is not selfish or tone-deaf.

Oh look I made it through without saying “cultural hegemony” or “ruling class”.

The tl;dr

Yes I put it at the end. Sorry not sorry.

The ultimate point of that meandering diatribe which probably didn’t come through is that we all have beliefs that don’t serve us in any functional way, and actually serve to empower the ruling class by means of cultural hegemony. These norms are so intrinsic to the way we’re raised that it’s incredibly difficult to spot them without explicit effort, and even then breaking the cycle is hard - you can watch other people succumb to these beliefs, point them out, have them agree with you and then continue to perform them simply because they can’t quite give themselves permission to break rank. None of us truly can because the power of how the crowd thinks and acts is a powerful, heady pheremone. It’s almost like breaking the laws of physics. Like magic.

00007-to-write

Tue Feb 15 12:11:06 2022 +0000

Why write at all?

I’ve been thinking a lot lately about how I want to share my work.

It’s pretty difficult for me to engage with sharing these days because of what the idea of “sharing” even entails these days. When you share something, that usually means that you’re clicking (clicking… how archaic!) a button on a social media site or app to effectively redistribute that thing within a context that’s somehow related to you. This is often to the aims of reinforcing your personal brand, driving up “engagement” or simply just a reflex reaction. It’s what you do on the modern internet.

This has been such a big question in my mind because the things I’ve been working on of late have been… They’ve been weird (Normally I’d dive into that but I’m trying this thing where I don’t fall into some completely unscoped meandering prose on whatever discursive topic comes to mind).

And that’s a core feature of esotericism - the semiotics of any esoterica are designed such to illicit a response from the “initiated”, but when you’re working on your own esoterica in some dark corner and you decide you want to share your work, who do you share it with? Which bits do you explain first? Explain at all?

The only way to understand, really, is to do. So I promised myself this morning that I’d write something tonight, working towards sharing my work. I like to write because it takes what’s internal to your mind, the vague discursive processes that feel concrete and completed, and actually forces serialization and by extension, internal consistency. You make those links explicit where they’re there and removes them where they aren’t. It’s a process of conceptual solidification. I’m just not very structured about it :P

It’s a marathon not a race, however, and whilst I’d like to write something good and considered and structured in consistent, clear and entertaining prose, instead I’m going to settle for just turning up for my attendance mark and to rebreak the seal.

I would like to write about the work I’ve been doing with Plan 9 and occultism, but to do that I think I need to begin to understand what I want to share, why and with whom. This is the first step, and hopefully I’ll be doing it by writing here. We shall see.

00006-crossbow-and-gdb

Thu Aug 13 12:31:29 2020 +0100

Yesterday I took a break from work for half an hour to just do some of my own futzing about, and I came back to something I’d already been playing around with, which was attempting to figure out why the feed processor I’d just downloaded and built wouldn’t handle the main feed, https://www.databreaches.net/feed/ that I wanted to view.

cRoSSbow

I first found out about crossbow on this lobste.rs post and decided it was probably right up my alley. I’ve written and spoken elsewhere about work I’ve done previously with feeds, primarily on my betterfeed framework for reconstituting RSS feeds.

I’m fully aware however, that my solution is super heavyweight, has a lot of code that I probably wouldn’t have needed to write myself in any other language, and is just not really usable for others.

So crossbow looked like a great solution. Looking at the man page for crossbow-cookbook it has all sorts of examples like:

Download the full article
    This scenario is similar to the previous one, except that the item description
    contains only part of the content, or nothing at all.  The link field contains a
    valid URL, which is intended to be reached by means of a browser.

    In this case we can leverage curl(1) to do the retrieval:

                crossbow set -i "$ID" -u "$URL" \
                    -o subproc \
                    -f "curl -o %n.html %l"
                    -C /some/destination/path/

This is a much more tractable way of doing similar to what I was already doing, but composable on the command-line. I could easily throw in a pipeline to pup for a given feed and re-use my extant CSS selectors in order to still just pull the actual content out.

But after downloading, building and installing the full set of dependencies and the project itself, I tried to use a very similar invocation to the one above to add https://www.databreaches.net to crossbow’s download list, returning 0, but when I ran crossbow-fetch I got the cryptic error message:

crossbow-fetch: cannot open feed [https://www.databreaches.net/feed/]: error_code=2 (mrss: Parser error)

God dammit.

Now I could probably have just dug through the code, but I don’t have much patience for that, and I have been having some amount of fun and success recently in turning to…

gdb

This isn’t my first rodeo with gdb, but I’m not a prolific writer of compiled languages nor am I an accomplished reverse engineer - I’m largely interested in building up my skillset because I (fairly recently) purchased a debugger for ARM devices.

Anyway, I’m going to cut a long story short here, but I learned a few things:

How to “break” (technically it’s a catch) on a syscall (in this case clone because I wanted to see what was going on in another thread)
How to lock the scheduler so other threads don’t continue to run in the background
How to step through a thread in the foreground
How to enable source listing for stepping through code with debug symbols compiled in

Again, to cut a long story short the error logic I wanted to see was in the libmrss.so.0 dependency, which in my efforts I ended up recompiling and installing separately to /usr/local/... and loading in with LD_PRELOAD in my gdb invocation.

I then did the following:

dir ~/libmrss/src to get the line information corresponding to the debug symbols
catch syscall clone to create a breakpoint when a thread is about to be created
run because the next scheduler argument doesn’t want to work until you start the program (we’re safe because we’ll break before threads are created)
set scheduler-locking on in order to prevent other threads from being scheduled whilst stepping through the current one.

We can then step (s) until the new thread is created and switch to it with:

info thread to view the threads and their IDs
thread 2 if you want to, for example, switch to the thread with id=2

I mean turns out none of the important stuff actually happened in the second thread which returns before thread 1 actually does the work that produces the error, but it’s a good thing to have learned.

Anyway, here’s the interesting bit:

(gdb) s
mrss_parse_url_with_options_error_and_transfer_buffer (feed_size=0x0, feed_content=0x0,
        code=<optimized out>, options=0x0, ret=0x7fffffff9440,
        url=0x7fffffffd480 "https://www.databreaches.net/feed/") at mrss_parser.c:1114
1114      if (nxml_parse_buffer(doc, buffer, size) != NXML_OK) {
(gdb) s
1121      if (!(err = __mrss_parser(doc, ret))) {
(gdb) s
__mrss_parser (doc=0x555555563560, ret=ret@entry=0x7fffffff9440) at mrss_parser.c:1015
1015      if (!(cur = nxmle_root_element(doc, NULL)))
(gdb) s
1018      if (!strcmp(cur->value, "rss")) {
(gdb) s
1042      else if (!strcmp(cur->value, "RDF"))
(gdb) s
1045      else if (!strcmp(cur->value, "feed"))
(gdb) s
mrss_parse_url_with_options_error_and_transfer_buffer (feed_size=0x0, feed_content=0x0,
        code=<optimized out>, options=0x0, ret=<optimized out>,
        url=0x7fffffffd480 "https://www.databreaches.net/feed/") at mrss_parser.c:1133
1133      nxml_free(doc);

Well up until I came to write about this, in my mind it was the case that the feed was atom so that’s why libmrss couldn’t parse it, but in checking my facts to be able to actually post examples this doesn’t appear to be the case.

This is not the feed you’re looking for

The feed itself is RSS and the library does have support for Atom as far as I can tell.

So going back through, let’s see what that root value is if it’s not rss:

Thread 1 "crossbow-fetch" hit Breakpoint 3, __mrss_parser (doc=0x555555563560,
        ret=ret@entry=0x7fffffff9440) at mrss_parser.c:1015
1015      if (!(cur = nxmle_root_element(doc, NULL)))
(gdb) s
1018      if (!strcmp(cur->value, "rss")) {
(gdb) p cur->value
$1 = 0x555555563600 "html"
(gdb)

Well there’s a turnout for the books. If I curl the URL, it’s definitely returning RSS. I bet this is user-agent related.

To test the theory out, I add a test feed that’s pointing to my website and tail the nginx logs, doing both a crossbow-fetch and a regular curl:

77.97.102.36 - - [13/Aug/2020:11:09:18 +0000] "GET / HTTP/1.1" 200 2090 "-" "-"
77.97.102.36 - - [13/Aug/2020:11:09:55 +0000] "GET / HTTP/1.1" 301 178 "-" "curl/7.71.1"

So the libcurl being used by nxml_download_file isn’t passing any user-agent header.

Let’s see what databreaches.net thinks of this:

<!DOCTYPE html>
<!--[if lt IE 7]> <html class="no-js ie6 oldie" lang="en-US"> <![endif]-->
<!--[if IE 7]>    <html class="no-js ie7 oldie" lang="en-US"> <![endif]-->
<!--[if IE 8]>    <html class="no-js ie8 oldie" lang="en-US"> <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en-US"> <!--<![endif]-->
<head>
<title>Attention Required! | Cloudflare</title>
<meta charset="UTF-8" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=Edge,chrome=1" />

Well there we go, Cloudflare has decided that I’m not allowed to see content because I haven’t told them what my UA is (╯ °□°）╯︵ ┻━┻

Sticking a pin in it

I need to have a bit of a think about the best way to proceed (and I need to get some real work done) so here are some options:

Set up an HTTP proxy that keeps track of which site wants which UA and uses it accordingly
Add a UA argument for crossbow-fetch
Go the whole hog and add support to both crossbow-fetch and crossbow-set so that UA can be set for each feed

I don’t want to put in too much speculative work for something that might not be accepted upstream, so I’m going to stick a pin in this and come back to it later.

00005-avra-kadabra

Thu Jul 16 10:57:03 2020 +0100

Deep arcana

I am, for one reason or another, attempting to build a PAL output serial terminal. Let’s just assume that’s a reasonable thing to do because my writing style doesn’t really sustain getting bogged down in explaining myself.

Having learned over the years that diving straight in the deepend doesn’t always produce results, I’ve decided that for my first pass I should probably do this with more modern technology, and have opted to use the microcontroller that is ubiquitous in my life, a knockoff Arduino Pro Micro. This board sports an Atmel ATmega32u4 which is most common in hobbyist USB keyboards which is why I have them just kicking around everywhere.

Saucery

I’m not great with electronics outside of some real basics of digital electronics and this is a truly analogue project where voltages matter, so I’d be pretty lost without this amazing page where the author builds PAL games out of PIC microcontrollers. They step through all the theory beautifully and then the practicalities of getting the full range of voltage outputs necessary for character output on 2 IO pins. Perfect for me, so I’m not going to paraphrase - if you want to understand just read it!

Avra Kadabra

The article says that timings are incredibly important, and I can only assume that’s true because my attempts at producing PAL output in C didn’t appear to do the trick as far as a TV was concerned, and looking at it under a logic analyzer I also have my suspicions. Timing sensitive C is not my forte, so I started to take a stab at AVR asm.

For whomever comes after me, I’m leaving these words together so that modern search engines (as fucking unhelpful as they are) can still point you to the right place: atmega32u4 avra assembly

The assembler

You’re looking for avra which is available under a few distros - in Arch it’s in the AUR and builds and installs with no problem.

The invocation is:

avra -I ./include -o main.hex main.asm

… which will produce a flashable hexfile (if you’re converting your makefile from C to ASM don’t leave avr-objcopy in or you’ll spend hours flashing garbage to your controller). The equivalent Makefile is below:

AS=avra
ASFLAGS=-I ./include

%.hex: %.asm
    $(AS) $(ASFLAGS) -o $@ $<

Notice I’m using a local include/ directory…

The chip

avra does not ship with the definitions required for the ATmega32U4. It ships with the definitions for the ATmega32 which, if you compare with the datasheet, does not put the registers at the same memory locations.

I’ll save you some effort here:

mkdir include
cd include
wget https://raw.githubusercontent.com/DarkSector/AVR/master/asm/include/m32U4def.inc

For some reason or other the chips need to be hardcoded into avra too, and it only has definitions for the ATmega32, and will complain about the .DEVICE directive in the include pointing to a microcontroller it doesn’t know.

You need to change the .DEVICE definition to ATmega32 and it will work just fine (at least for simple IO use cases). You can double check what your version of avra supports by doing avra --devices

Do the include

With the avra flags set as above and the modified file in your local include directory, all you need to do then is:

.include "m32U4def.inc"

And you can refer to the port definitions by their friendly names :)

In my case I’m actually liable just to cherry-pick the bits I need out once I’ve got my PoC, as PAL is actually super simple and I only really need the definitions for DDRD and PORTD

Flashing

It would be pretty unfair of me to not share a working solution, so here’s my entire Makefile

.ONESHELL:
SHELL=/bin/bash
TARGETS=pal.hex
DEFAULT:$(TARGETS)
CC=avr-gcc
AS=avra
ASFLAGS=-I ./include

%.hex: %.asm
    $(AS) $(ASFLAGS) -o $@ $<

flash_%: %.hex
    while ! avrdude -p m32u4 -c avr109 -U flash:w:$<:i -F -P /dev/ttyACM1; do sleep 1; done

clean:
    rm -f *.bin *.hex

Notables

I’ve been lazy and hardcoded in the port for flashing /dev/ttyACM1 - this is trivially fixable
avrdude is in a loop so that I can dispatch the command and then reset the microcontroller to flash
clean doesn’t have all the targets yet, but now is the time for writing, not for fixing. avra dumps a bunch of stuff out to disk.
In this format the invocation is make flash_pal for e.g. pal.hex

00004-yeet

Mon Jun 29 20:31:49 2020 +0100

How is this even magic?

So obviously I said that this blog is about magic, but ultimately it’s about magic with computers, and there’s an equivalence between arcane magic and arcane computing: oldnessness.

Around this time you should be realizing that you only have yourself to blame for reading material that’s this contrived.

But in all seriousness, I don’t actually think that computers work by magic, there’s always a deeper understanding to be had of the “sufficiently advanced technology” to make it distinguishable from magic, and there’s more “coagula” to be had the more you “solve”. Or something. So before embarking on Fuzix, I decided to play around a little with CP/M and utilizing the filesystem junk that’s provided for free as part of RomWBW.

Files

By default, an unpartitioned SD card (I assume that’s what it is, I took it straight from the packaging and dumped it into the SPI adapter) is broken up into “slices” of 8MB because CP/M is adorable and that’s all it can handle. On booting into CP/M with a ludicrously overprovisioned 16GB card installed:

    Boot Selection? C

    Loading CP/M 80 v2.2...



    CBIOS v3.0 [WBW]

    Formatting RAMDISK...

    Configuring Drives...

       A:=MD1:0
       B:=MD0:0
       C:=SD0:0
       D:=SD0:1
       E:=SD0:2
       F:=SD0:3
       G:=SD0:4
       H:=SD0:5
       I:=SD0:6
       J:=SD0:7

       1932 Disk Buffer Bytes Free

    CP/M-80 v2.2, 54.0K TPA

    B>

Here A: is (I assume) an as-yet uninserted (by virtue of being nonexistant) floppy drive, B: is the flash ROM with RomWBW et al on (and our current drive as indicated by the prompt) and C: onwards are the drive labels for the slices.

I can list C: thusly:


    B>dir
    B: ASM      COM : CLRDIR   COM : COMPARE  COM : COPY     CFG
    B: COPY     COM : DDT      COM : DDTZ     COM : DUMP     COM
    B: ED       COM : FA16     CFG : FDISK80  COM : FILEATTR COM
    B: FILEDATE CFG : FILEDATE COM : FLASH    COM : INITDIR  CFG
    B: INITDIR  COM : LDDS     COM : LDP2D    COM : LINK     COM
    B: LOAD     COM : MBASIC   COM : NULU     COM : PIP      COM
    B: PUTDS    COM : RELOG    COM : RMAC     COM : STAT     COM
    B: SUBMIT   COM : SUPERSUB COM : TD       CFG : TD       COM
    B: UNARC    COM : XSUB     COM : ZAP      COM : ZCAL     COM
    B: ZCNFG    COM : ZCNFG24  CFG : ZDE      COM : ZPATH    COM
    B: ZSCONFIG COM : ZXD      CFG : ZXD      COM : ASSIGN   COM
    B: FDU      COM : FORMAT   COM : MODE     COM : RTC      COM
    B: SURVEY   COM : SYSCOPY  COM : SYSGEN   COM : TALK     COM
    B: TIMER    COM : XM       COM : INTTEST  COM : CPM      SYS
    B: ZSYS     SYS
    B>

yeet

So I mentioned in one of my previous posts that I like the idea of being able to self-host on this thing, so for starters I’d love to have some docs available seeing as old tools are so user hostile. To do this, I’ll need to be able to copy files across.

XM is an implementation of XModem which is a protocol for transferring files over serial.

A quick google tells us that it’s possible to set up the XM receive with:

XM R C:SOMEFILE.TXT

and to send over the screen session by typing the leader and then:

: !! exec sx somefile.txt

And you’ll end up with SOMEFILE.TXT in your C: drive. all on one line because CP/M uses DOS-style line endings.

Obviously this is a bit of a 3-point turn, and I don’t want to store my copies of these files on Linux with dos line endings, so I wrote yeet:

#!/usr/bin/env bash
set -xe

FILE=$(readlink -f $1)
DEST="C:$(basename $FILE)"

if ! [[ -f $FILE ]]; then
        echo "$FILE is not a file" >&2
        exit 1
fi

screen -p 0 -X stuff "XM R $DEST\n"
sleep 1
screen -p 0 -X exec '!!' bash -c "unix2dos < $FILE | sx -"

This is a pretty rudamentary version with lots of things hardcoded, but essentially it uses the fact that you can send commands to screen from outside of the session.

What yeet does is grab the full path to the file, then extract the file’s basename and tell screen to type XM R C:SOMEFILE.TXT\n into the session (so you need to be at a CP/M prompt)

It then waits a second just in case (it’s not like this sleep command is even the longest delay anyway) and then runs the command exec !! bash -c "unix2dos < /path/to/somefile.txt | sx -" which will send the XModem formatted file as piped to stdin from the output of unix2dos so that not only do we get the file sent, but it’s also got the correct line terminators.

This all works surprisingly well

What next?

Well for starters, the contents of ZDE.TXT which is the full manual for the ZDE visual text editor is too large to open in the ZDE visual text editor - it runs out of memory - and the TYPE command dumps the whole thing without paging, so writing a pager in Z80 ASM seems like a good next project to learn about the platform.

Also, there’s the clear case of the reciprocal command for yeet to fetch a file. This will be trivial, and I also have a name for it.

Because “yeet” is like, Gen-Z slang or something, and it was best explained to me as the reciprocal of the word “yoink” in the phrase:

The Lord yeeteth, and The Lord yoinketh away.

00003-sc130

Fri Jun 26 14:19:06 2020 +0100

Z80

For one reason or another I’ve been thinking a lot about building a computer from scratch.

One reason: To have a platform to fuck about with which isn’t older than I am and thus a piece of destroyed history if I fuck it up
Or another: I’m not entirely convinced that the collapse of the global supply chain won’t happen and I’ll be left trying to scavenge chips in order to build and repair computers so that I can bask in the warm glow of information whilst I die of dysentary in my soiled sleeping bag in the back room of an abandoned Tesco Metro.

I’m not going to lie, CollapseOS put the thought into my mind and my tattooist makes some compelling arguments as to why life as we know it will draw to a close. Any certainty to the contrary at least just sounds like the desperate clamourings of cognitive dissonance trying to deny an impending Bad Thing.

But regardless, much like addressing global warming, the thing is that even if The Event doesn’t happen, I’ll have learned a bunch and honestly in lockdown you can’t have too many hobbies.

So like many (at least 2) great thinkers before me I’ve decided to go for a platform that is understandable, robust and ubiquitous enough - the Zilog Z80.

Z180 Yeah except I wasn’t paying an awful lot of attention so after I

assmebled the SC130, a lovely little starter board designed by Steve Cousins, having a bit of a Google around about my new platform I realised that the Z180 is not in fact just a Z80 in another package… But it looks to be a great springboard regardless as it’s fully Z80 compatible with some extra bells and whistles. I suppose there’s no need to jump straight from i7s to an abacus anyway.

Anyway, here it is in all it’s assembled glory. The build and test instructions were fantastic, especially the page where the purpose of every component on the board was explained. This is part of the reason it’s such a great board - it’s entirely comprehensible.

Resources for the SC130 are all hosted at Small Computer Central but I will be taking an archive naturally ;)

The bleak future.

So I have the computer working just great. The 512KB ROM comes with ROMWBW pre-flashed, which is a firmware bundling a bunch of things including CP/M, ZSDOS, Forth and Basic (not to mention a baked in 2048 clone)

Storage

It’s not exactly the most self-sufficient thing just yet though. For starters, I need some safely writeable storage which is going to come in the form of the SPI microSD card adapter (although you can actually modify the flash if you un-bridge the write-protect jumper). I’m off to pick up a couple today.

Human interface

Then I need to figure out how to make it a standalone computer by giving it it’s own video out and keyboard input. This could be pretty interesting, there are boards out there but I’d really love to learn something by building my own solution. This could either be a standalone serial terminal module, or an actual graphics output for the board itself (which would allow me to continue to draw sigils which is likely what I’ll want to do shortly before I get attacked by roaming maurauders.

Self-hosted

A self-sufficient computer should be able to self-host. This might be a tricky one, but I’m probably going to have a play with Fuzix later today which apparently has its own C compiler. This would obviously be great if it’s actually a self-hosted OS because I’m already familiar with Unix paradigms,

Failing this it’s going to be about learning CP/M or ZSDOS and figuring out how to use either the Forth interpreter or ASM to build out new features.

There’s also CollapseOS which is designed to self-host and to also bootstrap other tech - I’d love to see if I can flash an AVR from it!

This is all tremendously exciting though

The super-distant bleak future

Power

Ever since I’ve thought of the idea, I’m taking it to logical extremes in my head… The most hilarious of these is that I’ve kinda wanted to build a generator for a while, probably out of a lawnmower or motorcycle engine or something.

I love the idea of building it into a computer and having the computer actually regulate the thing too. It would be a great party piece at hacker camps.

EMP

I mean whilst we’re at it, if I’m going to be a complete fucking lunatic, we may as well also build it into a faraday cage to protect the ICs from global thermonuclear war. Fuck it, why not.

Display

This is the thing I’m still unsure about - what will the ubiquity of displays be like after The Event? I think building a standalone RS232 terminal that can output to VGA and composite is probably the best scavenging solution, but then again most displays are HDMI these days which means they likely have a limited shelf life and would need a more complex microcontroller than the Z80 itself just to output anything.

In conclusion

Yes I am managing to keep myself busy during lockdown

00002-ancient-lisp

Sat Jun 20 19:09:48 2020 +0100

Antiquity

One of the things that’s common to the vast majority of grimoires is that they claim antiquity, which is not something I really buy in to in most senses - I can understand some weight being put behind the idea that a practice has lasted because it worked, but the idea that “these sigils were definitely written down by King Solomon” really carries no particular weight to me.

As a mental anchor point though, it’s so culturally ingrained that it’s an excellent way to quickly and easily attribute importance to a thing, and thus an incredible tool in your arsenal to generate gravitas around things you want to focus on.

Sigilum

I was working on some code to generate magical sigils in the style of Crowley’s re-interpretations of the sigils in The Lesser Key of Solomon. By which I mean that he put them in circles with names of the angels and demons around them.

My implementation was using PyCairo, and I wrote the code to produce the “name circle” (optionally in the Malachim alphabet) around generated “*grams” starting with a pentagram. Now as a proof of concept this was probably a great place to start and I was able to generate some kinda weird stuff at least for visuals in my CampGND talk, but my next artefact is really supposed to be something to carve into my desk.

I say “supposed” because I created a servitor with the express intent of finding said sigil, which means that I have to complete the task now or the spell didn’t work. Yeah I’m not even going to get into that logic now but suffice to say I intend to complete the goal.

One of the things that was stopping me from working on the code was that I didn’t really enjoy it - fact of the matter is I don’t like writing Python for a number of reasons that you could probably call aesthetic, but the most important one being that it doesn’t really feel very occult. Yeah you heard me right, Python doesn’t feel occult enough. It feels like an anachronism when used for occult means.

You know what programming dialects feel like channeling the powers of the universe? Lisps.

Knights of the Lambda Calculus

Now before I embark on these “ideas of antiquity” I should probably clarify something very important out of the historical associations that exist along the timeline of Lisp, from MIT’s AI lab to Emacs Lisp: Richard Stallman is a relic of outdated ideas surrounding what kind of behaviours merit will excuse. Fuck that guy.

With that out of the way, Lisps and Schemes map somewhat more literally to ideas like lambda calculus at the birth of computer science and were considered the holy grail of programming languages back in the days of heavy iron. They were above and beyond what the priesthood manning the IBM mainframes were thinking about, and largely beyond the capacity of the computers of the time. Sometimes it feels like programming with algebraic precision.

That said, I first tried to rewrite in Racket. I’m now pretty sure that image.rkt is written for teaching in the DrRacket IDE, not summoning Satan or whatever. I also realised something about Lisps.

I switched back to an old heavyweight which I have come to the conclusion has totally ruined other lisps for me: Clojure.

And it’s like being in an old comfy pair of trousers. Powerful trousers with deep arcane powers, and a function that you probably want to use that does that one thing (whatever it is) for you.

My code now adequately separates out the data processing (i.e. the real magic, the sacred geometries) from the horrible impure side-effecty programming that is rendering shit to an image. Additionally, rather than using a completely underpowered image library I’ve used quil which is more geared towards 3D live-coding visualizations, so overpowered instead of under.

What next

I’ve already implemented the full featureset that I already had in significantly less time with significantly less code. Additionally because of my emacs setup it’s got all sorts of mad symbols for lambdas and partials which makes it look super arcane ;) I even aliased tau (2 * pi) to its greek letter heh. Next I want to do the following:

Define the point joining pattern by passing a lambda or generator or some other callable to dictate which points get joined to which others. This should be a great way of finding some gnarly looking patterns
Use the animation functionality of quil to create motion in the sigils
Think some more about generation of non-gram patterns. Previously I’ve achieved this by pasting images of dickbutt in the center.

00001-entry

Sat Jun 20 19:09:48 2020 +0100

Start as you don’t mean to continue

I hate writing thinkpieces and “new blog” posts, because I get completely lost. The problem being that I’m an engineer in all aspects, and when I write I like it to be about what I did and what worked - you can’t misjudge your audience or make false claims or generalisations when doing this because the audience is whoever is interested in what you did, and it’s definitely true because you were there.

I want this blog to be about my experiences in magic and technology, and I’ve written and deleted about 3 particularly stuffy statements of belief that I can’t get to the end of because of wild tangents because I feel like I need to contextualize. So I guess I need to summarise it in like, 3 sentence and then call it good enough.

I believe that any power in religion or magic comes from the practice and frameworks of focussing the will (i.e. a technology for doing so) and that anything achieved from doing so is done under the agency of the individual or individuals participating in the practice.

I hypothesize that the techologies of religion, magic and the occult likely have further use in self mastery under recognition of the fact that the human mind is fundamentally irrational and unless particularly well practiced, is not incredibly obedient to the mind.

Finally I believe that technology does not have enough aesthetic value, and that a ritual is basically just a protocol with a sense of style.

To summarise, you could say that I’m an irrational rationalist or a rational irrationalist - I want to learn from historical techniques of the occult and religion in order to develop my own to become the most effective individual I can be. This may or may not include doing things that sound like I believe in the supernatural, but I don’t. I’m just an engineer with limited time and limited scruples as to which mileau I’ll engage in to have an interesting and “effective” life.

Okay that was pretty good. Blog style: keep it brief so you don’t bore yourself hahah.