Oatmeal

Snorlax leaning into the whole vibe of her namesake.

At the start of this year I set out to revive my long dead reading habit. After having kids it fell by the wayside. I’ve read 41 books so far this year. Mostly a mix of science fiction and nonfiction computer science books. Here’s the complete list of everything I’ve read. I’ve got mixed feelings about keeping track and sharing counts of whats been read in a year — it isn’t about quantity, but I do enjoy being able to look back at a log of what I’ve read.

Some notable works:

Record of a Spaceborn Few, by Becky Chambers took my breath away again and again, a book that hooked me right from the start.

I loathed nearly every moment of The Ministry for the Future, by Kim Stanley Robinson.

Madeline Miller’s Circe was one of the most beautiful things I’ve read in a long while.

This is How You Lose the Time War, by Amal El-Mohtar and Max Gladstone was probs my favorite read of the year.

Programming from the Ground Up, by Johnathan Bartlett is one of ’em that I want to revisit because I know I need to pay better attention to it than I did the first time round.

I didn’t set out to read mostly science fiction and computer science books, I sort of fell into them. I’m thinking next year I’ll follow some whims and build some themes to read around; mystery is top of the list.

---

After engaging in my little tour of computer science flavored books I think most programming books do too much of the wrong thing. Rather than pick a lane and run, they float between a few spaces:

• Tutorials, learning-oriented (teaching someone to cook)
• How-to guides, problem-oriented (a recipe for cooking a specific thing)
• Explanation, understanding-oriented (historical overview of an ingredient’s cultural importance)
• Reference, information-oriented (an encyclopedia article about an ingredient)

I think there is a lot of space for programming books that don’t try to be everything, but pick one of the above and go all in.

I think each of these types maps fairly well to an audience:

• Tutorials are for folks who are totally new to a thing
• How-to guides are a step up from tutorials and help you learn idioms and best practices of a space
• Explanation is useful when needing to convey the value of a thing
• Reference is generally for experts who are cozy doing the thing

Instead, most programming books try to be everything to everyone for every occasion. I think just about all the books I read had a preamble about “who’s this book for” and they’re all basically for the same kind of person according to all those preambles…someone who isn’t necessarily an expert, but familiar with the basic concepts of programming.

…but maybe this is also biased by the sorta books I was picking up?

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.

Break thrones. Build tables.

Over the past couple years I’ve done the advent of code to varying degrees. I thought I was going to do it again this year but decided to try something different. I’ve been calling what came together a “December Adventure.”

It isn’t anything fancy; throughout December I aim to write a little bit of code everyday. So far I’ve written a bit of apl, bash, elisp, explored a bunch of flavors of scheme, and started to (but not yet finished) write applications in racket and lil.

A few other folks have joined in — to make it a bit of a community event some of us started to log our adventures and post about them…but there aren’t really any rules. One of the reasons I didn’t want to do the advent of code again was that it was feeling really competitive. A couple years ago it felt fun, playful, but these days it seems pretty corporate and less about exploring or learning anything new and more about being the quickest, something that I think is sort of endemic across the industry: quick is more important than curiosity.

I’ve been enjoying it, and it has been fun to keep up with everyone else’s December adventures.

We visited a troll in the woods this evening.

The idea is that as you start to find patterns in your application, you can encode them in a little language—this language would then allow you to express these patterns in a more compact manner than would be possible by other means of abstraction. Not only could this buck the trend of ever-growing applications, it would actually allow the code base to shrink during the course of development!

A while ago someone asked what I liked about the programming languages I like — forth and lisp specifically.

I’ve noodled on it for a bit now, and I think the reason I like forth and scheme and other languages with something like a repl is because when I start a new project I’m dropped right into the entire language and the sky is the limit…everything is already right there.

When I start a project in Java or Go it feels empty; instead of having a system to play with I have to craft a Rube Goldberg machine of boilerplate code and then gingerly feed the compiler code like shoveling coal into a furnace.

Happy birthday hugs

If they aren’t weekly, I guess they’re occasional?

3rd repair procedure to fix brain bleed was a success. I have a few more scans and follow ups, but, knock wood I think I’m through at this point.

I’ve spent about a week laying low and taking it easy navigating some wild pain, but that is subsiding now. I watched a bunch of stuff. It was a nice change of pace. I don’t typically watch much television or many movies. Stand outs (all things I revisited) include:

• Michael Clayton
• Point Break, the original one
• John Carter of Mars, straight up…this movie is awful. The book is pretty awful, too, but they just don’t make bananas sci-fi like this any more
• Bee and Puppycat, this one was weird — I’d seen it all through and loved it…I was surprised to see how different the Netflix version is from what I remember.

---

I’ve continued reading about and exploring some array programing languages. I find them fascinating. I doubt that I’ll ever do much with any, but they’re fun to think through and make me wanna play with combinators in other settings…also, matrices.

Another language recently stumbled on is lil. It is a scripting language baked into a cool little project called Decker. Learn even more about it.

The language is strange, and exciting — it allows for some interesting combinations of imperative, functional, and array programming styles.

---

No doubt ya’ll have heard about the goings on at Twitter. I haven’t been on Twitter for years, but do love myself some fediverse-action. Lately it has been getting some attention.

A cool mastodon trick for anyone wading into the waters for the first time:

I’ve used the fediverse for years and ended up moving from server to server a few times. It is useful to have a quick shorthand for folks to find you without always giving them your exact handle — if you have your own website you can use that as a form of identity without needing to host your own server!

To pull this off you need to add a file at <your personal domain name>.tld/.well-known/webfinger

Paste the contents of https://<name of mastodon instance>.tld/.well-known/webfinger?resource=acct:<your user name>@<name of mastodon instance>.tld into the webfinger document on your server. From there, you are cooking with fire!

You can then search for fedi@eli.li and your main account will show up in the results. It is sort of like an alias.

NOTE <anything>@<your domain>.tld will trigger this. As far as I know there is no way to lock it to a specific handle, since, this isn’t really a feature as much as an easily exploited bug of the lookup system.

---

No super notable links of late. On a meta note I use pinboard.in to collect and organize links; I’m growing a wee bit concerned about pinboard is withering on the vine. I recently tried to export my gigantic archive from it and…no dice? Days later I emailed support and no response. Anyone have favorite alternatives? Either pay-for, or self hosted. Ideally I’d like it to be able to grab the linked content. I’ve used wallabag in the past and wouldn’t mind returning to it, I’ve just been slowly trying to back away from self hosting services and pinboard seemed oh so reliable when I moved to it a few years back.

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.

We found a big mushroom.

Am I allowed to call them “week notes” if I don’t do them weekly?

I went in for what was supposed to be my final brain scan, a diagnostic angiogram (don’t look that up). The good news is that the repair has officially cured my brain bleed! The bad news is that they saw another vessel that looks primed to bleed; I’m due for another repair procedure sometime in October. I’m pretty bummed to not be done with this ordeal, but trying to remain optimistic that this new one was caught before it bled and because the surgeon says this one seems easier to repair than the first.

I’m still struggling to focus long enough to pick up major programming tasks at hobby time (I desperately wanna make this game that I’ve been noodling over and over for months now). Sorry if I’ve promised you something, or a fix, or anything, and haven’t made that happen yet.

That said, I’ve enjoyed re-building my VPS. This time an OpenBSD box. I’ve got a few personal utilities running on it, but am also using it as a programming language playground.

Looking back over my link logging from the last few weeks, there isn’t much of note that isn’t boring computer-stuff. The stand-out item is a recent find: Mycorrhizae, A songbook of fungal myths, a gorgeous zine.

Since my brain injury (which I’ve since learned can be called an “ABI” or “acquired brain injury”) I’ve noticed that I have trouble focusing on programming tasks; I’m able to do what I need to do for work and family but, when it comes time for hobby projects I’m just gloop. Totally oozy.

Because of that I’ve been drawn to do more reading and game playing, but also still wanna code…I’ve found that it is easier to use more “batteries included” kinda languages, namely scheme, over what I’d normally gravitate towards, like Forth.

This has lead me to some interesting thoughts of the “accessibility” of programming languages.

---

I’ve been reading a lot. As of today, I’m 34 books deep into this year. I’m really pleased with my choice to revive my reading habit. I’ve read a smattering of fiction, new-to-me, and re-reads, as well as a number of nonfiction books — mostly programming books.

Maybe I’ll do a round up post at the end of the year? In the meantime some standouts include:

• The entire Wayfarers series by Becky Chambers, especially Record of a Spaceborn Few
• This is how you Lose the Time War by Amal El-Mohtar and Max Gladstone
• Circe by Madeline Miller (the audiobook for this is phenomenal! One of the best I’ve ever listened to)

---

My VPS suffered a wonderfully catastrophic failure during an upgrade, you may notice some of my web presence is currently down while I re-configure some things over the next few…weeks?

…probably months.

Blog will keep trucking, though!

---

Some recent discoveries

• strse, an incredible string DSL for scheme
• ~dozens gives a tour of ed, the standard editor
• a totally feature complete “ECS,” entity component system, for lua, and some more on entity component systems
• 4-Die Chess: A New Kind of Chess, from Erin Bern
• A Zen Guide to Paper and Pen Games
• keeping the theme alive, hexapawn
• A nice overview on the accessibility of QR codes