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… before taking a hard turn into the private sector to follow my PhD advisor.

Since then, I’ve worked in the computer security space at a couple of different companies. Some don’t exist any more, some you’ve probably heard of. I still program for fun too, and not just in security.

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

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.

AoC 2022 Day 23: Elf Scattinator

2022-12-23

Source: Unstable Diffusion

Part 1

Implement a cellular automaton with the following rules:

If you have no neighbors, don’t move (important, I forgot this one for a while)
Otherwise:
- Calculate a potential move:
  - If you have no neighbors to the north, move north
  - If not, check likewise for south, then west, than east
- If no other agent is moving to the same space, move to your potential move
- Otherwise, don’t move
On each frame, rotate the order the directions are checked in (NSWE, SWEN, WENS, ENSW, NSWE, …)

AoC 2022 Day 22: Wonderator

2022-12-22

Source: Monkey Map

Part 1

Given a map and a series of instructions formatted as distance + turn (L or R), find the final position. Any time you would walk off the edge of the map, wrap to the opposite edge.

AoC 2022 Day 21: Yellinator

2022-12-21

Source: Monkey Math

Part 1

Given a series of equations of either the form dbpl: 5 or cczh: sllz + lgvd, determine what the value of the node labeled root is.