a bunch of domains owned by webshell authors expired, leaving backdoors in the webshells up for grabs

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

microforum in DNS TXT records

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

one of my favourite RFCs probably

Some thoughts on custom allocator interfaces with nice examples.

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

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!

The book, focusing on Homo sapiens, surveys the history of humankind, starting from the Stone Age and going up to the twenty-first century. The account is situated within a framework that intersects the natural sciences with the social sciences.

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.

MLIR is an interesting LLVM compiler framework thingy that uses LLVM for multiple representations instead of just high-level assembly.

This tutorial runs through the implementation of a basic toy language on top of MLIR. The goal of this tutorial is to introduce the concepts of MLIR; in particular, how dialects can help easily support language specific constructs and transformations while still offering an easy path to lower to LLVM or other codegen infrastructure. This tutorial is based on the model of the LLVM Kaleidoscope Tutorial.

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.

Push key blocks into their slots to gain control of the qwert. Regain Ctrl (and possible other keys) to get to the get through to the end. There are fourteen levels total. Can you get through them all?

Abstract: Polymorphic inline caches (PICs) provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site. For a set of typical object-oriented SELF programs, PICs achieve a median speedup of 11%.

SimpleX Chat - a private and encrypted messenger without any user IDs (not even random ones)! Make a private connection via link / QR code to send messages and make calls.

Designed to bring aggressive C-like optimizations to the largest variety of JavaScript programs.

Fling, jet, grapple and roll through a psychedelic world as you experience the bizarre mating rituals of alien jellyfish. You'll need careful timing and strategy to explore every cleft and cranny in this chill but challenging 1-button arcade game.

A recording debugger promising to “reduce the debugging time dramatically”.