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?
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).
Latency, throughput and port usage of x86 instructions.
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
Something about tying abstract models to Rust programs, looks useful.
An IRL spatial computer making use of printed codes to do stuff.
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.
Looks useful if I ever install DAP.
May be a replacement for a current postfix+dovecot+rspamd+L+ratio setup. Notably supports JMAP, although most clients don’t anyways.
Uses ast-grep, so tree-sitter, not LSP, but still potentially useful.
Has some interesting features like “View HIR”, grouped code actions and failed test diagnostics.
Looks super cool, I’ll have to remember it when I next need to do network diagnostics.
Interesting for tree-sitter textobjects.
Could it be?.. A sensible looking Neovim colorscheme?..
Looks useful, although I don’t remember any context in which it would be useful. Worth a try anyway.
Probably useful if I ever run out of disk space.
Looks interesting, supports cancellation and other useful stuff.
Pen-and-paper secret sharing, looks fun. Don’t know how I would ever use this though.
sadly, doesn’t provide links, but most is googlable
Enables std debug assertions + presents an interface for building with a sanitizer.
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.
A distributed network that allows you to add host-independent repo identifier as a git origin. Looks like it worth a try, especially with sr.ht being down and Codeberg half-broken because of a DDoS attack.
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.
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
Another take on io_uring in Rust. Doesn’t bring its own runtime, instead choosing to integrate with tokio.
How OpenBSD prohibited all syscalls from unknown locations.
Looks really cool. I wonder what’s inside.
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.