fasterthanli.me

Highlighted code in slides

2024-11-23T17:40:00Z

I have obsessed about this long enough, I think it's only fair I (and you!) get some content out of it.

When I started writing this article, I was working on my P99 CONF slides. Those slides happen to include some bits of code. And because I'm a perfectionist, I would like this code to be syntax highlighted, like this:

let addr: SocketAddr = config.address.parse()?;
let ln = TcpListener::addr?
 configbase_url

ktls now under the rustls org

2024-09-26T21:10:00Z

What's a ktls

I started work on ktls and ktls-sys, a pair of crates exposing Kernel TLS offload to Rust, about two years ago.

kTLS lets the kernel (and, in turn, any network interface that supports it) take care of encryption, framing, etc., for the entire duration of a TLS connection... as soon as you have a TLS connection.

For the handshake itself (hellos, change cipher, encrypted extensions, certificate verification, etc.), you still have to use a userland TLS implementation.

State of the fasterthanlime 2024

2024-08-07T07:14:05Z

It's time for some personal and professional news!

TL;DR: I started a podcast with James, I'm stable on antidepressants, I'm giving a P99 CONF about my Rust/io_uring/HTTP work, I'm trying on "they/them" as pronouns, I'm open-sourcing merde_json, rubicon and others, I got a divorce in 2023, I found a new business model.

Now that we're on the same page: let's unpack this a bit!

Face cams: the missing guide

2024-03-02T18:00:00Z

I try to avoid doing "meta" / "behind the scenes" stuff, because I usually feel like it has to be "earned". How many YouTube channels are channels about making YouTube videos? Too many.

Regardless, because I've had the opportunity to make my own mistakes now for a few years (I started doing the video thing in earnest in 2019), and because I've recently made a few leaps in quality-of-life re: shooting and editing video, I thought I'd publish a few notes, if only for reference for my future self.

Just paying Figma $15/month because nothing else fucking works

2023-10-19T16:50:00Z

My family wasn't poor by any stretch of the imagination, but I was raised to avoid spending money whenever possible.

I was also taught "it's a poor craftsman that blames their tools", which apparently means "take responsibility for your fuckups", but, to young-me, definitely sounded more like "you don't deserve nice things".

I was also taught from an early age that I was born a sinner, incapable of doing good by myself, and that all the earthly things were temptations, sent by the devil to corrupt me (further I guess?) but also temporary, and that I shouldn't attach myself.

Cracking Electron apps open

2023-07-03T16:30:00Z

I use the draw.io desktop app to make diagrams for my website. I run it on an actual desktop, like Windows or macOS, but the asset pipeline that converts .drawio files, to .pdf, to .svg, and then to .svg again (but smaller) runs on Linux.

So I have a Rust program somewhere that opens headless chromium, and loads just the HTML/JS/CSS part of draw.io I need to render my diagrams, and then use Chromium's "print to PDF" functionality to save a PDF.

The RustConf Keynote Fiasco, explained

2023-05-31T21:00:00Z

Disclaimer:

At some point in this article, I discuss The Rust Foundation. I have received a $5000 grant from them in 2023 for making educational articles and videos about Rust.

I have NOT signed any non-disclosure, non-disparagement, or any other sort of agreement that would prevent me from saying exactly how I feel about their track record.

Disclaimer:

I was part of the RustConf program committee in 2022, but not in 2023. More on that later.

Rust: The wrong people are resigning

2023-05-28T17:04:00Z

(Note: this was originally posted as a gist)

Reassuring myself about Rust

Up until recently, I was part of two private online discussion spaces where a bunch of Rust people hung out.

So, whenever there was drama, like when the entire mod team resigned, or when a trademark draft got a lot of people seriously worried, or just recently when RustConf took back the keynote from ThePHD then Sophia resigned over it and , I had some place to go, to assess how serious things were this time around.

Extra credit

2023-03-05T07:30:12Z

We've achieved our goals already with this series: we have a web service written in Rust, built into a Docker image with nix, with a nice dev shell, that we can deploy to fly.io.

But there's always room for improvement, and so I wanted to talk about a few things we didn't bother doing in the previous chapters.

Making `clash-geoip` available in the dev shell

When we ran our app locally, we signed up for a MaxMindDB account, and had to download and unpack the "Country" Geolite2 database manually.

Generating a docker image with nix

2023-03-05T07:30:11Z

There it is. The final installment.

Over the course of this series, we've built a very useful Rust web service that shows us colored ASCII art cats, and we've packaged it with docker, and deployed it to https://fly.io.

We did all that without using nix at all, and then in the last few chapters, we've learned to use nix, and now it's time to tell docker build goodbye, along with this whole-ass :

Making a dev shell with nix flakes

2023-03-05T07:30:10Z

In the previous chapter, we've made a nix "dev shell" that contained the fly.io command-line utility, "flyctl".

That said, that's not how I want us to define a dev shell.

Our current solution has issues. I don't like that it has import <nixpkgs>. Which version of nixpkgs is that? The one you're on? Who knows what that is.

Also, we haven't really seen a mechanism to use files from elsewhere.

Learning Nix from the bottom up

2023-03-05T07:30:09Z

Remember the snapshot we made allll the way back in Part 1? Now's the time to use it.

Well, make sure you've committed and pushed all your changes, but when you're ready, let's go back in time to before we installed anything catscii-specific in our VM.

This should emulate the experience of a colleague onboarding onto the project well enough!

(I didn't actually use VirtualBox's snapshot feature for this, I actually set up a Ubuntu 22.10 VM on another computer entirely, but the effect should be much the same).

Doing geo-location and keeping analytics

2023-03-05T07:30:08Z

I sold you on some additional functionality for catscii last chapter, and we got caught up in private registry / docker shenanigans, so, now, let's resume web development as promised.

Adding geolocation

We kinda left the locat crate stubby, it doesn't actually do any IP to location lookups. It doesn't even have a dependency on a crate that can do that.

So, let's do that. We'll use the crate, which can read the MaxMind DB format, like GeoIP2 and GeoLite2:

Using the Shipyard private crate registry with Docker

2023-03-05T07:30:07Z

Wait wait wait, so we're not talking about nix yet?

Well, no! The service we have is pretty simple, and I want to complicate things a bit, to show how things would work in both the Dockerfile and the nix scenario.

And because I don't like contrived examples, we're going to do something somewhat real-world: we're going to geo-locate visitors, and track how many visits we get from each country.

Deploying catscii to fly.io

2023-03-05T07:30:06Z

Disclaimer:

Because I used to work for fly.io, I still benefit from an employee discount at the time of this writing: I don't have to pay for anything deployed there for now.

fly.io is still sponsoring me for developing hring, but this isn't a sponsored post. It's just a good fit for what we're doing here, with a generous free tier.

In the previous chapter, we've written a to build the service inside Docker. The result is a container image that can be pushed to production!

Writing a Dockerfile for catscii

2023-03-05T07:30:05Z

Now that our service is production-ready, it's time to deploy it somewhere.

There's a lot of ways to approach this: what we are going to do, though, is build a docker image. Or, I should say, an OCI image.

This is still a series about Nix, but again: because the best way to see the benefits of Nix is to do it without Nix first, we'll use only Docker's tooling to build the image.

Installing Docker on Ubuntu

Serving ASCII cats over HTTP

2023-03-05T07:30:04Z

Our catscii program does everything we want it to do, except that it's a command-line application rather than a web server. Let's fix that.

Enter `axum`

The documentation for the axum crate tells us how to make a basic web server, and we honestly don't need much more than that.

So let's add axum:

amos@miles:~/catscii$ cargo add [email protected]
    Updating crates.io index
      Adding axum =0.6 to dependencies.
             Features:
             + form
             + http1
             + json
             + matched-path
             + original-uri
             + query
             + tokio
             + tower-log
             - __private_docs
             - headers
             - http2
             - macros
             - multipart
             - w

Printing ASCII cats to the terminal

2023-03-05T07:30:03Z

Now that our development environment is all set up, let's make something useful!

Creating the `catscii` crate

From a VS Code window connected to our VM (as we just set up), let's make a new Rust project:

amos@miles:~$ cargo new catscii
     Created binary (application) `catscii` package

And open it in a new VSCode window:

amos@miles:~$ code catscii

Even though we're running this "code" command in the VM guest, VSCode set up enough plumbing that it communicates back to the host, telling it to open another VSCode window, connected to the same SSH remote, in the right folder.

Developing over SSH

2023-03-05T07:30:02Z

With the previous part's VM still running, let's try connecting to our machine over SSH.

Network addresses, loopback and IP nets

Normally, to connect to a machine, you'd find its IP address. On Linux, a decade ago, you would've used ifconfig. Nowadays you can use ip addr:

The loopback interface (lo) is local, so it's not useful to reach the box from the outside: you can see it can be accessed over IPv4 at address 127.0.0.1 but not just! What we're reading here is 127.0.0.1/8, which corresponds to the range

Setting up a local Ubuntu Server VM

2023-03-05T07:30:01Z

The first step to using Nix to build Rust is to do so without Nix, so that when we finally do, we can feel the difference.

There's many ways to go about this: everyone has their favorite code editor, base Linux distribution (there's even a NixOS distribution, which I won't cover). Some folks like to develop on macOS first, and then build for Linux.

Y'all are all valid, but for this series, we're going to very specifically do what I before nix, and what I'm doing now that I've embraced my 30s and become "a nix person", and we'll evaluate the ups and downsides of both approaches.

The bottom emoji breaks rust-analyzer

2023-02-13T14:20:00Z

Some bugs are merely fun. Others are simply delicious!

Today's pick is the latter.

Reproducing the issue, part 1

(It may be tempting to skip that section, but reproducing an issue is an important part of figuring it out, so.)

I've never used Emacs before, so let's install it. I do most of my computing on an era-appropriate Ubuntu, today it's Ubuntu 22.10, so I just need to:

$ sudo apt install emacs-nox

Day 18 (Advent of Code 2022)

2023-01-12T14:00:00Z

This time around, we're porting a solution from C++ to Rust and seeing how it feels, how it performs, and what we can learn about both languages by doing that.

See Day 17 for the rationale re: porting solutions rather than writing my own from scratch. TL;DR is: it's better than nothing, and we can still focus about learning Rust rather than spending entire days fighting off-by-one errors.

The research for this article was done live on stream, I'm not going to cover everything in the write-up, so check it out if you want the full experience:

Twitch fell behind

2023-01-12T13:00:00Z

So you want to do live streams. Are you sure? Okay. Let's talk about it.

Let's talk numbers

Being a "content creator" (sorry for those who hate that term) is a job, for sure, and many people do it, successfully, full-time, they pay rent with it etc.

Platforms like Twitch & YouTube would have you think that, if you put in enough effort, you can grow your channel from nothing to 🎉 profitable ✨ in just a few short years.

Day 17 (Advent of Code 2022)

2023-01-11T15:00:00Z

Advent of Code gets harder and harder, and I'm not getting any smarter. Or any more free time. So, in order to close out this series anyway, I'm going to try and port other people's solutions from "language X" to Rust. That way, they already figured out the hard stuff, and we can just focus on the Rust bits!

Sounds good? Good. Let's proceed.

The research for this article was done live on and , if you'd rather watch me go through it step by step, you can watch the VOD below:

Day 16 (Advent of Code 2022)

2022-12-29T15:00:00Z

Let's tackle the day 16 puzzle!

Parsing

The input looks like this:

Valve AA has flow rate=0; tunnels lead to valves DD, II, BB
Valve BB has flow rate=13; tunnels lead to valves CC, AA
Valve CC has flow rate=2; tunnels lead to valves DD, BB
Valve DD has flow rate=20; tunnels lead to valves CC, AA, EE
Valve EE has flow rate=3; tunnels lead to valves FF, DD
Valve FF has flow rate=0; tunnels lead to valves EE, GG
Valve GG has flow rate=0; tunnels lead to valves FF, HH
Valve HH has flow rate=22; tunnel leads to valve GG
Valve II has flow rate=0; tunnels lead to valves AA, JJ
Valve JJ has flow rate=21; tunnel leads to valve II

fasterthanli.me

Highlighted code in slides

ktls now under the rustls org

What's a ktls

State of the fasterthanlime 2024

Face cams: the missing guide

Just paying Figma $15/month because nothing else fucking works

Cracking Electron apps open

The RustConf Keynote Fiasco, explained

Rust: The wrong people are resigning

Reassuring myself about Rust

Extra credit

Making clash-geoip available in the dev shell

Generating a docker image with nix

Making a dev shell with nix flakes

Learning Nix from the bottom up

Doing geo-location and keeping analytics

Adding geolocation

Using the Shipyard private crate registry with Docker

Deploying catscii to fly.io

Writing a Dockerfile for catscii

Installing Docker on Ubuntu

Serving ASCII cats over HTTP

Enter axum

Printing ASCII cats to the terminal

Creating the catscii crate

Developing over SSH

Network addresses, loopback and IP nets

Setting up a local Ubuntu Server VM

The bottom emoji breaks rust-analyzer

Reproducing the issue, part 1

Day 18 (Advent of Code 2022)

Twitch fell behind

Let's talk numbers

Day 17 (Advent of Code 2022)

Day 16 (Advent of Code 2022)

Parsing

Making `clash-geoip` available in the dev shell

Enter `axum`

Creating the `catscii` crate