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 really interesting exploration of interpreter design, a lot of repls and thoughts on various coroutines

a really cool post explaining design of gc-arena

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.

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.

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.

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.

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 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.

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.

A nice overview of STM primitives.

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

A nice post about SIMD algorithms using Rust’s portable SIMD as an example.

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!

Variables are the trickiest part of lambda calculus. And naming is the trickiest part of variables: the most complex code in our lambda evaluator is the part that renames variables to perform capture-avoiding substitutions.
Names are artificial tedious tags whose sole purpose is to aid human comprehension. Can we get rid of them? There ought to be a way to study computation without naming names.

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.

This blog post is one of those things that just blew up. From a tiny observation at work about odd behaviors of spinlocks I spent months trying to find good benchmarks, (still not entirely successful) writing my own spinlocks, mutexes and condition variables and even contributing a patch to the Linux kernel. The main thing I’ll try to answer is to give some more informed guidance on the endless discussion of mutex vs spinlock. Besides that I found that most mutex implementations are really good, that most spinlock implementations are pretty bad, and that the Linux scheduler is OK but far from ideal. The most popular replacement, the MuQSS scheduler has other problems instead. (the Windows scheduler is pretty good though)

a whirlwind tour through the guts of the system

Tutorial about building a self-hosting cargo-compatible build tool. I have many problems with cargo and was interested in nixifying our job builds for eternity, so maybe there’s something useful there.

What if all software suddenly disappeared? What's the minimum you'd need to bootstrap a practical system? I decided to start with a one sector (512-byte) seed and find out how far I can get.

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.

The paper’s claim:

False.

Compilers do optimize atomics, memory accesses around atomics, and utilize architecture-specific knowledge. This paper illustrates a few such optimizations, and discusses their implications.

Interestingly, none of the optimizations proposed in the paper actually work on GCC or Clang.

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.

When it comes to security, we care about limiting access of each entity of a system to as few other entities as possible. Network input, executables and users must be able to reach only those resources, which are necessary to perform the defined server tasks. Principle of least priviledge.

Generally, it's better to implement as many layers of security as possible. Although, there is no way to make a server 100% bullet proof - it's a huge endless topic, this article covers some feasible essential systemd tunables that give us a layer of protection.

Introspectable and extensible IDEs with logic programming

In this blog post we explore how to write a type level contains operation for HList inspired type lists without running into overlapping trait implementations

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.

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

Presented in an experimental mnemonic medium that makes it almost effortless to remember what you read

It turns out that finite state machines are useful for things other than expressing computation. Finite state machines can also be used to compactly represent ordered sets or maps of strings that can be searched very quickly.

Fourier transforms are a tool used in a whole bunch of different things. This is a explanation of what a Fourier transform does, and some different ways it can be useful.

If you're curious about rainbows, colorimetry, gamma encoding, and experiments run in the late 1920s, then this is the post for you!

A lot about sockets, syscalls and bits