Automerge is a local-first sync engine for multiplayer apps that works offline, prevents conflicts, and runs fast.

Welcome to “stupid jj tricks”. Today, I’ll be taking you on a tour through many different jj configurations that I have collected while scouring the internet. Some of what I’ll show is original research or construction created by me personally, but a lot of these things are sourced from blog post, gists, GitHub issues, Reddit posts, Discord messages, and more.

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

A well-equipped ASCII diagram builders freely available on the internet.
It stresses portability, simplicity, and immediateness.

My take on what could be a project template for Django advanced usage, with modern tooling (for Python and UI dependencies, as well as configuration/environment management), but not too opinionated.

Everything you need to write flexible, future-proof Rust applications using hexagonal architecture.

There's a concept that I've heard called by a lot of different names, but my favorite name for it is …

The expression problem describes how most types can easily be extended with new ways to produce the type or new ways to consume the type, but not both. When abstract syntax trees are defined as an algebraic data type, for example, they can easily be extended with new consumers, such as print or eval, but adding a new constructor requires the modification of all existing pattern matches. The expression problem is one way to elucidate the difference between functional or data-oriented programs (easily extendable by new consumers) and object-oriented programs (easily extendable by new producers). This difference between programs which are extensible by new producers or new consumers also exists for dependently typed programming, but with one core difference: Dependently-typed programming almost exclusively follows the functional programming model and not the object-oriented model, which leaves an interesting space in the programming language landscape unexplored. In this paper, we explore the field of dependently-typed object-oriented programming by deriving it from first principles using the principle of duality. That is, we do not extend an existing object-oriented formalism with dependent types in an ad-hoc fashion, but instead start from a familiar data-oriented language and derive its dual fragment by the systematic use of defunctionalization and refunctionalization. Our central contribution is a dependently typed calculus which contains two dual language fragments. We provide type- and semantics-preserving transformations between these two language fragments: defunctionalization and refunctionalization. We have implemented this language and these transformations and use this implementation to explain the various ways in which constructions in dependently typed programming can be explained as special instances of the phenomenon of duality.

Using systemd to avoid having to write some risky code

Go programming language is known to be easy to use. Thanks to its well-thought syntax, features and tooling, Go allows writing easy-to-read…

Hard disagree on this one, but still interesting.

Living specification of the IRC protocol. Does not include brand new behavior, just existing behavior present in IRC software and/or networks (new extensions are IRCv3's area).

Rust and Node aren't bad for encouraging dependency use -- your favorite language's tools just suck.