semi-interactively explains how TLS works, very cool

an extremely based frontend manual from the GOV.UK

a fun case study with Zig’s comptime

Slowly booting full Linux on the intel 4004 for fun, art, and absolutely no profit

a really fun (albeit somewhat impractical) way to compress webpages when all you have is browser APIs

how user agents became a lying mess

a paper explaining some reasons not to trust Matrix. includes pearls like “a homeserver can silently add user to a E2EE group and decrypt all the following messages and that’s not considered a vulnerability”.

a fun implementation of *Kanren with nice Haskell interoperability. showcases some fun Haskell featues.

a really interesting exploration of interpreter design, a lot of repls and thoughts on various coroutines

a really cool post explaining design of gc-arena

a fun way to serialize binary data to pronouncable identifiers

Lix is an independent variant of the Nix package manager, developed by a team of open-source volunteers, and maintained by and for a passionate community of users.

I kind of assumed that Lix is a purely political fork, but they seem to write actual code, so that’s nice. Changelog promises faster evaluation, better errors and REPL improvements.

Report about software found on North Korean smartphones.

This offers an interesting technical analysis of systemd (in part 3). I’m not a huge fan of the social/historical parts (1-2, 4), although they offer some perspective.

Very much not-production-ready (didn’t even compile on my machine), but looks pretty cool (rad, even).

A bottom-up, animated guide to HTTP load balancing algorithms.

In this blog, we go on an interactive journey to understand common queueing strategies for handling HTTP requests.

microforum in DNS TXT records

An IRL spatial computer making use of printed codes to do stuff.

sadly, doesn’t provide links, but most is googlable

With some partial evaluation and specialization hints, it is possible to get pretty decent speedups on interpreters by turning them into compilers.

one of my favourite RFCs probably

git clone --recursive --remote-submodules https://github.com/asyncmeow/git-infinite-recursion.git

How we built an anonymous Zig/C++ crash reporter that doesn't require debug symbols to be shipped with the application.

Pretty fun and showcases some Zig comtime stuff.

A paper about choosing “nothing-up-my-sleeve” numbers while having stuff up your sleeve.

A fascinating tale about network problems.

A nice explanation of async that’s not about “threads slow”, but rather about how async as an abstraction emerges from sensible design decisions.

Allows you to find Unicode characters by drawing them.

The Rust language has incrementally grown a set of patterns to support control-flow effects including error handling, iteration, and asynchronous I/O. In The registers of Rust, boats lays out four aspects of this pattern shared by Rust’s three effects. Today these effects are typically used in isolation, or at most combined in bespoke ways, but the Rust project has been working on ways to integrate them more deeply with each other, such as async gen blocks.

The theory of algebraic effects and handlers has explored this design space and offers answers to many of the questions that the Rust project has encountered during this work. This post will relate the patterns employed by Rust to the terminology and semantics of effects, to help build a shared vocabulary and understanding of the implications of combining multiple effects.

gstreamer-plugins-bad includes a NES 6502 emulator, which was vulnerable to RCE.

Review of many different software vulnerabilities caused by obscure undertested (mis-)features.

A modern web browser is the software equivalent of Gabriel’s Horn. Finite volume, but infinite attack surface.

This post is all about speculative compilation, or just speculation for short, in the context of the JavaScriptCore virtual machine.

Some thoughts on custom allocator interfaces with nice examples.

Comparison between different runtimes and with native code.

The generic dilemma is this: do you want slow programmers, slow compilers and bloated binaries, or slow execution times?

No generics / monomorphization / dynamic dispatch

How OpenBSD prohibited all syscalls from unknown locations.

About why free functions are important. I find verb/noun framework from this article quite useful.

A very nice paper about fuzzing Rust compiler by generating custom MIR. Found some bugs in both rustc and LLVM, but notably not in Cranelift.

This is an opinionated essay about good and bad practices in data visualization. Examples and explanations are below.

Microbenchmark for futexes + spinlocks and some useful links at the bottom.

Because spin locks are so simple and fast, it seems to be a good idea to use them for short-lived critical sections. For example, if you only need to increment a couple of integers, should you really bother with complicated syscalls? In the worst case, the other thread will spin just for a couple of iterations…
Unfortunately, this logic is flawed! A thread can be preempted at any time, including during a short critical section. If it is preempted, that means that all other threads will need to spin until the original thread gets its share of CPU again. And, because a spinning thread looks like a good, busy thread to the OS, the other threads will spin until they exhaust their quants, preventing the unlucky thread from getting back on the processor!

This is the closing-file-handles-on-Windows post.

I'm titling this post Surprisingly Slow because the slowness was either surprising to me or the sub-optimal practices leading to slowness are prevalent enough that I think many programmers would be surprised by their existence.

The Go standard library’s net.IP type is problematic for a number of reasons. We wrote a new one.

This post explores some problems with Go’s “simplicity by design”: introducing a better IP type that’s also interoperable with the language proves to be a non-trivial challenge.

Dungeons and Dragons, but about philosophy.

Paper about how IT in healthcare in general and IT security in particular is done by people who don’t actually use it, listing different problems and workarounds that end up being used in the field.

Sacrificing convenience for security leads you to having neither security nor convenience.

Niko’s post about using vectors (≈ arenas) instead of reference counters to model graphs. Explains how it relates to ownership and borrowing.

See also: Handles are the better pointers.

A blog post explaining the “single owner of data, everyone has indices instead of pointers” model. Not actually about Rust per se, just happens to be really useful for Rust.

See also: Modeling graphs in Rust using vector indices.

A first (as far as I know) description of ringbuffer based on two mmaps. I hope to make a better one sometime, but for now this’ll the best explanation I have.

Explanation of provenance, uninitialized memory and stuff like that. Useful as an entry point into realization that we don’t live in PDP-11 world anymore.

Life is hard. Some days are at the absolute limit of what we can manage. Some days are worse than that. Eating—picking a meal, making it, putting it into your facehole—can feel like an insurmountable challenge. We wrote this cookbook to share our coping strategies. It has recipes to make when you’ve worked a 16-hour day, when you can’t stop crying and you don’t know why, when you accidentally woke up an Eldritch abomination at the bottom of the ocean. But most of all, this cookbook exists to help Sad Bastards like us feel a little less alone at mealtimes.

tl;dr: /dev/random is obsolete and /dev/urandom is strictly better except in early boot.

A free book about atomics and locks that also serves as a nice cheatsheet for x86_64, aarch64 and futexes.

An example of false sharing in real-ish workload.