« Oatmeal

What follows is my attempt to spark a conversation in a few converging, but separate communities I lurk in.

I’ve already had a bunch of amazing conversations around this topic with a lot of people. Those conversations helped to shape what follows. Thanks to everyone who was willing to think this stuff through with me.

Before I get into it I want to say at the top this isn’t meant as an accusation against anyone in these communities, nor the goals of the various projects. This is intended to add a new layer to the existing considerations and to see if the goals of these projects can be expanded to include, or consider, accessibility.

---

I want to open a conversation about accessibility in this space.

I think it is an important consideration mostly left out of our community’s conversations.

I think it’s an important conversation for a variety of reasons —

Facet, ignoring it tacitly implies there isn’t space for folks who rely on assistive tech in our community, that they can’t contribute and aren’t imagined to matter in the future.

Facet, we often look back in time to older devices, implementations and implementers. For many of them the concerns of capitalism placed constraints on what they could achieve. We’re speculating about a post-capitalist ecosystem…as such, we have an opportunity to think outside of those confines. Thinking about accessibility invites us to look forward while also pulling inspiration from the past. We have constraints, they’re a different looking set than the ones on things like the apple 2, we needn’t let those constraints define our future.

Before I turn the conversation over I want to set a few core assumptions:

• accessibility is more than screen readers
• disability is something that takes a variety of forms, it is something some folks live with forever, it is something that visits some other folks briefly
• disability can compound; sometimes we need to consider more than 1 disability at a time
• disability can be visible, disability can be invisible

A first instinct may be to think of accessibility as a technical problem that needs a solution. I’d suggest that it might be an opportunity to reframe how we approach the idea itself; from accessibility to adaptability. Adaptability of methodology, problem solving, software, and devices.

This evening I sat down on the couch sleepy. We’d just gotten the kids into bed. I hadn’t planned on writing any code but figured I’d round the evening out with some reading.

First I read through the docs and glossary of uf, a forth system for uxn. Then I read through an example program provided by uf.

…with my palette whetted I re-visited some other forth documentation.

Then I put things down and did the dishes. After doing the dishes I found myself back at a keyboard ready to write some code.

My first thought was to re-implement the unix command cat in uxntal. After a bit of noodling I decided to go with echo instead of cat. I banged away at echo for a bit but then remembered the very first program demonstrated in a book I’m currently reading, Programming from the Ground Up, by Jonathan Bartlett. The first sample program there is one that exits. That is about it.

Exiting felt achievable.

Here is a teeny tiny program that prints the string Hello Uxn! and then exits.

( exit )

|10 @Console &vector $2 &read $1 &pad $5 &write $1 &error $1

|0100 ( -> )

    ( print hello )
    ;hello-txt

    &while
        LDAk .Console/write DEO
        INC2 LDAk ,&while JCN
    POP2

    ( exit )
    #010f DEO

BRK


@hello-txt "Hello 20 "Uxn! $1

It isn’t much, but it is a start.

Some handy resources I poured over over this evenings explorations include:

• uxntal library
• uxntal examples, specifically the devices examples
• regex.tal
• femto.tal
• grep.tal
• day 7 of compudanzas’s uxn tutorial
• uxnlin, a uxntal linter in uxntal

Also, big thanks to Devine Lu Linvenga, a primary force behind uxn, for pointing me in the right direction and suggesting some optimizations.

I’m not sure if I’ll have it in me to write code every night moving forward, but this was a lot of fun and I still have big dreams for a homespun cat.tal

As I look to assembly nights 2 and think of trying my own take on it, I wanna have a cozy space ready to play with uxn.

The setup I’ve landed on is sort of inspired by plan9port.

Prepare the way

• in home directory, create a u directory
• in u clone uxn and build it
• add ~/u/uxn/ to your path as $UXN
• add $UXN/bin to your path
• moving forward we’ll put any and all *.rom files into $UXN/bin

Utility scripts

• create script called u that contains the following

#!/bin/sh

UXN=${UXN:-$HOME/u/uxn}
export UXN

case "$PATH" in
$UXN/bin:*)
    ;;
*)
    PATH=$UXN/bin:$PATH
    export PATH
    ;;
esac

case $# in
[1-9]*)
       exec "$@"
       ;;
esac

• make u executable with chmod +x and mv it to /usr/local/bin or some similar space

• in $UXN/bin add the following scripts, make each executable with chmod +x

• lin, used to lint *.tal files before assembly.

# script name: lin
#!/bin/sh

u uxncli uxnlin.rom $1

• asm, used to assemble *.tal files into executable *.roms.

# script name: asm
#!/bin/sh

u uxnasm $1 $2

• run, used to run *.roms in the sdl2 uxn emulator.

# script name: run
#!/bin/sh

u uxnemu $1

• cli, used to run command line *.roms into stdin/stdout at the shell prompt.

# script name: cli
#!/bin/sh

u uxncli $1

• drif, an alternate assembler — this one is selfhosted and doesn’t support macros.

# script name: drif
#!/bin/sh

u uxncli drifblim.rom $1 $2

rom library

• wget the following roms into $UXN/bin

wget https://rabbits.srht.site/left/left.rom
wget https://rabbits.srht.site/drifblim/drifblim.rom

rock and roll

At this point everything is set and cozy to start exploring!

Do that like so:

• to lint a *.tal file,

u lin rad.tal

• to assemble a *.tal file using an assembler that supports macros,

u asm rad.tal rad.rom

• to assemble a *.tal file using the selfhosted assembler,

u drif rad.tal rad.rom

• to run a rom in the emulator

u run rad.rom

• to run a rom at the prompt

u cli rad.rom

• to edit something using left,

u uxnemu left.rom -s 2 rad.tal

NOTE: the -s 2 bit makes the program run zoomed…I’ve got bad eyesight and have a high DPI screen, you may not need that flag.

Onward!

Now, I’ll be honest — I don’t know if I’ll actually do my own flavor of assembly nights with uxn, but I’m really pleased with this little setup…so, that is a step in the right direction. The other step in the right direction I’ve taken is that I started to read Programming from the Ground Up by Jonathan Bartlett…so far, 2 chapters in, I am enjoying it a lot.

Uxn is an esoteric stack-machine with 32 bit instructions. It exists someplace at the intersection of a GameBoy, 6502 ASM, an Apple II, Forth, RetroForth, the z80, a Sinclair ZX Spectrum, and “what if Nausicaä from Studio Ghibli’s Nausicaä of the Valley of the Wind used a computer?” It is tiny, unlike most anything else around these days, and, once you wrap your head around it, pretty fun.

I won’t go into how to develop for it here (mostly because I’m not heaps good at that, not yet) but will walk you though how to get it running under a relatively recent release of macOS.

For more info on how to use it and develop programs for it see:

• Uxn’s primary repo
• Uxn
• Uxntal
• Varvara
• Uxn tutorial, this is a really excellent guide that walks you through how to write programs for Uxn using Uxntal.

Assumptions

I’m assuming that you, at a minimum know how to find and launch the terminal application on macOS. Opening Launchpad or Spotlight and typing “Terminal” should do the trick. Beyond being able to start the terminal application this assumes no prior knowledge of the command line nor Unix.

To run a Uxn rom you’ll need a Uxn emulator. There are a few of these out and about, but I’ll focus on the reference implementation here, Uxnemu.

This implementation has only one dependency, SDL2. SDL2 provides the audio/video bindings, as well as a few other niceties, to the host OS.

If you’ll be building Uxnemu from source you’ll need SDL2 to be installed on your machine. I’ll provide more information about that further on.

Quick and easy

If you don’t want to bother with installing anything other than Uxnemu you can download a build of it that includes SDL2 here.

When this downloads it’ll look sort of like a text file, not a normal application like you are probably used to. Before you run it you’ll need to change permissions on it to make the file executable (able to be run as a program). To do this you’ll have to launch the macOS’ terminal.

Once you’ve launched the terminal, either drag your downloads directory on to the terminal and press return on your keyboard, or type the following (assuming you’ve not changed the location of your system-standard downloads folder),

cd ~/Downloads

Then press retrun on your keyboard.

You’ve navigated to your downloads directory! Next up, we’ll make the freshly downloaded Uxnemu executable. To do this, type the following:

First, ensure that the file is present in the downloads folder:

ls

Then hit return.

You should see a list of all the contents of your downloads directory, including uxnemu. If you don’t see uxnemu you are either in the wrong directory or didn’t download it.

If you need to troubleshoot: check what directory you are in — type pwd and then hit return. This will display the current directory, it should return a string of text that ends in “Downloads.” If you are in the downloads directory and still don’t see uxnemu download it again and check to where it is being saved.

Once in your downloads folder with your fresh copy of uxnemu run the following commands to make it executable:

chmod a+x uxnemu

Hit return!

This command will make uxnemu executable. To test that it worked, run the following,

./uxnemu

Then hit return — you should see output like, usage: uxnemu file.rom. If you do, that means that it worked! You’ve now got yourself a working uxnemu emulator.

Snag a rom and go nuts!

Give it a go, download the piano.rom from here.

Now run,

./uxnemu piano.rom

A new window will open. You should see something along the lines of this!

Slightly more involved

Now, if you wanna get a little deeper into the weeds, you can assemble uxnemu from source. To do that, you’ll need to have some more pieces in place.

Preparing the way

Before we get started ensure that you’ve got all the necessary tools to build unxnemu’s C source. The easiest way to do this is to use macOS’ deeply middling package manager, brew. Before you install it, you’ll need to install the Xcode Command Line Tools (if you haven’t already, or if you haven’t installed the full, GUI, version of Xcode).

Here are directions for how to do that. Or, tl;dr wanna live dangerously xcode-select --install!

If you don’t explicitly needs Xcode, I recommend the command line tools over the full Xcode GUI because Xcode is ginormous, and will devour a computer’s disk-space.

Once you’ve got the Xcode Command Line Tools and brew installed you are almost ready. As mentioned above, Uxn depends on SDL2. We’ll use brew to install that.

Check that brew is working by looking for SDL2,

brew info sdl2

It’ll output something sort of like this if everything is working to plan,

With that command we ensured that sdl2 is available through brew, but haven’t yet installed anything. Eyes on the prize, you are ready to install sdl2. Do that by running,

brew install sdl2

That will output something along the lines of,

Note that brew can sometimes be bananas slow. Patience is key to this step.

Once brew is done doing its thing, and sdl2 is installed you are ready to start cooking with fire!

Doing the thing

The first step is to obtain the uxn source code. We’ll use git to do that. At the terminal,

git clone https://git.sr.ht/~rabbits/uxn

Then return.

This will download the uxn project. It’ll look something a bit like this,

Once that has completed, enter the directory you just cloned using git by typing,

cd uxn

Then return — from within that directory, now type,

ls

And then hit return on your keyboard. You’ll see a listing of the directory’s contents, like this

Now we’re reading to do the thing! Uxn comes with a handy script called build.sh. The script is a little program that can build uxnemu and a few other programs for you. To run it,

./build.sh

And return!

That will run the build script. The build script will build, and then run a default rom, like this!

At this point you should be good to go!

Building from source means that you have the uxnemu as well as the uxnasm.

The uxnemu is an emulator, capable of running assembled Uxn roms.

The uxnasm is an assembler, capable of assembling Uxntal files into roms for the uxnemu to run!

As I learn more about about Uxn I hope to write more about it, in the meantime, check out the great tutorial!