138 bookmarks saved.

Place where goldstein dumps his links so she doesn’t have 500 tabs ever again.

Tags are structured like this:

  • is- tags are about medium. Books, papers, blog posts, interactive explanations etc.

  • about- tags are about about. What’s this post topic or what’s this project is/for.

  • to- tags are about reason. Why did I even save this?

  • for- tags are about connections. Where can I use it?

systemd, 10 years later: a historical and technical retrospective

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.


effing-mad: Algebraic effects for Rust

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


Latency, throughput and port usage of x86 instructions.


Load Balancing

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


Queueing – An interactive study of queueing strategies

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



microforum in DNS TXT records


Типизированная математика by suhr

Understanding Real-World Concurrency Bugs in Go

Refinement Proofs in Rust Using Ghost Locks

Something about tying abstract models to Rust programs, looks useful.


Folk Computer

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


wayback: a personal web archiving tool.

Wayback is a web archiving and playback tool that allows users to capture and preserve web content. It provides an IM-style interface for receiving and presenting archived web content, and a search and playback service for retrieving previously archived pages. Wayback is designed to be used by web archivists, researchers, and anyone who wants to preserve web content and access it in the future.

about-tools,is-repo,to-try TigerBeetle’s code style guidelines

nvim-dap-virtual-text: shows variables values in virtual text

Looks useful if I ever install DAP.


stalwart: all-in-one mail server

May be a replacement for a current postfix+dovecot+rspamd+L+ratio setup. Notably supports JMAP, although most clients don’t anyways.


telescope-ast-grep.nvim: AST grep extension for telescope.nvim

Uses ast-grep, so tree-sitter, not LSP, but still potentially useful.


A Nix DSL for defining DNS zones

rustaceanvim: fork of rust-tools.nvim

Has some interesting features like “View HIR”, grouped code actions and failed test diagnostics.


nix-output-monitor: fun build progress display

trippy: A network diagnostic tool

Looks super cool, I’ll have to remember it when I next need to do network diagnostics.

about-networking,about-tools,is-repo,to-try Neovim Lua plugin to extend and create `a`/`i` textobjects. Part of 'mini.nvim' library.

Interesting for tree-sitter textobjects.


cdmill/neomodern.nvim: A collection of modern themes for Neovim

Could it be?.. A sensible looking Neovim colorscheme?..


srgn: tree-sitter-aware text replacement tool

Looks useful, although I don’t remember any context in which it would be useful. Worth a try anyway.


Best-Effort Extent-Same, a btrfs dedupe agent

Probably useful if I ever run out of disk space.


may: rust stackful coroutine library

Looks interesting, supports cancellation and other useful stuff.


Sjlver/psst: Paper-based Secret Sharing Technique

Pen-and-paper secret sharing, looks fun. Don’t know how I would ever use this though.


pineapple: colorscheme previewer for neovim

the nix iceberg

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


RalfJung/cargo-careful: Execute Rust code carefully, with extra checking along the way

Enables std debug assertions + presents an interface for building with a sanitizer.


Compilers for free with weval

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


RFC 9225: Software Defects Considered Harmful

one of my favourite RFCs probably



git clone --recursive --remote-submodules

about-vcs,is-repo,to-show is Bun's new crash reporter

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.


How to manipulate curve standards: a white paper for the black hat

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


The little ssh that (sometimes) couldn't

A fascinating tale about network problems.


Learning Async Rust With Entirely Too Many Web Servers

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.


A universal lowering strategy for control effects in Rust

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.


voidlizard/hbs2: P2P CAS / P2P Framework / Distributed GIT

A distributed network that allows you to add host-independent repo identifier as a git origin. Looks like it worth a try, especially with being down and Codeberg half-broken because of a DDoS attack.


ast-grep | structural search/rewrite tool for many languages

Treesitter-based AST search-and-replace. Supports lints via saved patterns, LSP diagnostics + quick fixes and a regular CLI. Sounds pretty cool for custom lints.


Compromising a Linux desktop using... 6502 processor opcodes on the NES?!

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


features are faults

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.


Speculation in JavaScriptCore

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


So you want custom allocator support in your C library

Some thoughts on custom allocator interfaces with nice examples.


Performance of WebAssembly (WASM) runtimes in 2023

Comparison between different runtimes and with native code.


The Generic Dilemma

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

No generics / monomorphization / dynamic dispatch


mfio: Completion I/O for Everyone

Another take on io_uring in Rust. Doesn’t bring its own runtime, instead choosing to integrate with tokio.


Pinning all system calls in OpenBSD

How OpenBSD prohibited all syscalls from unknown locations.


FireDBG: Time Travel Visual Debugger for Rust

Looks really cool. I wonder what’s inside.


prr: Review GitHub PRs from local editor

Software Transactional Memory: Clojure vs. Haskell

A nice overview of STM primitives.


Execution in the Kingdom of Nouns

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


Designing a SIMD Algorithm from Scratch

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


nix-std: no-nixpkgs standard library for the nix expression language

Semantic fuzzing of the Rust compiler and interpreter

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.


jaq: A jq clone focussed on correctness, speed, and simplicity

Friends don't let friends make certain types of data visualization

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


Linus Torvalds about spinlocks and locking in general

Efficient Userspace Optimistic Spinning Locks

How to spin before sleeping so that it actually helps and not harms?


Mutexes Are Faster Than Spinlocks

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


Spinlocks Considered Harmful

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!


Lambda calculus - Combinatory Logic

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.


Surprisingly Slow

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.


netaddr.IP: a new IP address type for Go

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.


Distributed Proofreaders

Distributed Proofreaders provides a web-based method to ease the conversion of Public Domain books into e-books. By dividing the workload into individual pages, many volunteers can work on a book at the same time.

1 3