The earliest memory I have of ‘programming’ is in the early/mid 90s when my father brought home a computer from work. We could play games on it … so of course I took the spreadsheet program he used (LOTUS 123, did I date myself with that?) and tried to modify it to print out a helpful message for him. It … halfway worked? At least I could undo it so he could get back to work…

After that, I picked up programming for real in QBASIC (I still have a few of those programs lying around), got my own (junky) Linux desktop from my cousin, tried to learn VBasic (without a Windows machine), and eventually made it to high school… In college, I studied computer science and mathematics, mostly programming in Java/.NET, although with a bit of everything in the mix. A few of my oldest programming posts on this blog are from that time.

After that, on to grad school! Originally, I was going to study computational linguistics, but that fell through. Then programming languages (the school’s specialty). And finally I ended up studying censorship and computer security. That’s about where I am today!

But really, I still have a habit of doing a little bit of everything. Whatever seems interesting at the time!

Popular Github Repos

ascii-canvas -- 11☆2ᛘ
house-on-the-hill -- 11☆
dnsscan -- 10☆8ᛘ
ios-backup -- 9☆
dotfiles -- 7☆3ᛘ
backup -- 4☆
chess-puzzles -- 3☆
advent-of-code -- 2☆
bit-struct -- 2☆1ᛘ
abc -- 1☆

Posts

Cloning Redis in Rust: RESP [Part 1]

2023-01-31

Recently, I read through Build Your Own Redis with C/C++. C/C++ are ugly, so let’s run through it in Rust!

My goal: implement some large subset of Redis (both server and client) in Rust. For any features I implement, it should be compatible with Redis off the shelf. I should be able to use their client with my server and their server with my client and it should just work.

No idea if this is going to work out, but it sounds like an interesting problem!

First task: the REdis Serialization Protocol (RESP).

Next/Previous 'Space' in Hammerspoon

2023-01-30

A quick somewhat hacky followup to Once Again, to Hammerspoon: moving windows to the next/previous Space on a single screen.

Once Again, to Hammerspoon

2023-01-23

Why oh why doesn’t macOS have a more powerful window manager…

Once upon a time, I moved from primarily Windows to primarily (at the time) OSX. I missed Aerospace–the ability to use Win+Left/Right to snap windows to half the screen–so I wrote a fix: Duplicating AeroSnap on OSX with Hammerspoon.

Since then, I eventually discovered and moved to Magnet and all was well.

But more recently, I’ve been wanting two things:

a bit more control (once again), to define more arbitrary sizes and keystrokes
the ability to automatically arrange windows to various Mission Control Spaces

And what a journey it’s been…

Local JS/CSS with Hugo Pipe

2023-01-19

I recently stumbled across a post that reminded me that Hugo has pipes. You can use them to automatically download files and include them as local. This seems like a pretty good idea for JS/CSS (you can argue caching versus security/locality all you want), but I’m going to give it a try.

Proc Macro Workshop: derive(Builder) [Part 2]

2023-01-17

Okay, in Proc Macro Workshop: derive(Builder) [Part 1] we created a derive(Builder) macro to implement the builder pattern. We created a new *Builder struct, created methods to set each field in a chain, and allowed some fields to be optional.

So what’s left? (Be sure to start with Part 1 if you haven’t read that!)

Let’s do this!

A Justfile for my blog

2023-01-16

For a while now, I’ve been using make as my task runner for my blog. make run to run locally, make deploy to build and push to GitHub pages.

But… the syntax isn’t great for some things and I’ve been working a lot with Rust. So let’s see what just can do!

Proc Macro Workshop: derive(Builder) [Part 1]

2023-01-15

While continuing to learn a bit more about macros in Rust (previous post), I really want to move beyond the simple declarative macros and get into something a bit more interesting. Enter procedural macros. In a nutshell, procedural macros in Rust, rather than relying entirely on pattern matching and expansion are fully Rust functions.

They take a specific input (a stream of tokens) and output a specific output (a new stream of tokens), but in between they can do just about anything a full Rust function can do. And what’s better yet… they operate at compile time. And because they operate on tokens (rather than a full AST), you can do things that just aren’t syntactically valid in normal Rust. Things like… variadic functions (a la print! or var!) or even crazier things like embedding Python in Rust for … reasons.

Today specifically, I’ve started working through the prod-macro-workshop repo. It’s a series of five examples macros with test cases and some guidance set up to help you get up to speed. I’m going to be working through the first of these: derive(Builder). Now don’t get me wrong. I really have no idea what I’m doing, so don’t take this as an example of how to write a macro. But perhaps by writing this out, it will help me learn it better… and if you happen to learn something as well, all the better!

Writing a curry! macro for MacroKata

2023-01-12

Recently I’ve been wanting to learn more about macros in Rust. It was always one of my favorite parts of Racket, so let’s see what we can do.

In order to do that, I’ve been following the excellent MacroKata series. It goes all the way through, starting with the very basics, adding in literals and expressions, handling repetition, nesting, and finally recursion.

What I really want to talk about those is the one that I found most interesting: curry!.

AoC 2022 Day 25: Snafuinator

2022-12-25

Source: Full of Hot Air

Part 1

Let a Snafu number be a base 5 number with the curious property that in addition to the digits 0, 1, and 2, it has the numbers - as -1 and = as -2. Sum up a list of Snafu numbers.

AoC 2022 Day 24: Blizzinator

2022-12-24

Source: Blizzard Basin

Part 1

Given a map with a series of moving walls (that wrap when the hit the edges of the simulation), calculate the fastest route from the top left to the bottom right.