20 random bookmarks

2025-09-29

135.

stupid jj tricks

andre.arko.net/2025/09/28/stupid-jj-tricks

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.

2025-08-25

130.

Everything I know about good API design

www.seangoedecke.com/good-api-design

2025-08-12

128.

missing.css

missing.style

2025-06-26

123.

Box combinators

mmapped.blog/posts/41-box-combinators.html

In functional programming,
combinator libraries refer to a design style that emphasizes bottom-up program construction.
Such libraries define a few core data types
and provide constructors—functions that create initial objects—and combinators—functions that build larger objects from smaller pieces.

Combinators enable the programmer to use intuitive visual and spatial reasoning
that’s vastly more powerful than linear language processing.
As a result, solving problems with combinators feels like playing with lego pieces.

2025-06-18

121.

You can use `fzf` to review git commits

jvns.ca/til/fzf-preview-git-commits

I just learned that
you can use it to review a git commit like this and I thought that was really
cool.

2025-06-13

117.

What I talk about when I talk about IRs

bernsteinbear.com/blog/irs

I have a lot of thoughts about the design of compiler intermediate representations (IRs). In this post I’m going to try and communicate some of those ideas and why I think they are important.

2025-05-23

112.

Async from scratch 1: What's in a Future, anyway? | natkr's ramblings

natkr.com/2025-04-10-async-from-scratch-1

There are a lot of guides about how to use async Rust from a "user's
perspective", but I think it's also worth understanding how it
works, what those async blocks actually mean.

2025-05-06

107.

Debian installation with encrypted BTRFS

chaos.tomaskral.eu/guides/debian-encrypted-btrfs-root

2024-12-17

91.

Advent of Code on the Nintendo DS

sailor.li/aocnds.html

Solving AoC on the DS with Rust.

2024-11-22

89.

New stuff in Emacs 30

www.mgmarlow.com/words/2024-07-28-emacs-30-news

Reading through the Emacs 30 NEWS file and picking
out the stuff I think is the most interesting.

2024-09-16

74.

Wayland: i3 to Sway migration

anarc.at/software/desktop/wayland
73.

Technical Writing One introduction

developers.google.com/tech-writing/one

2024-06-24

51.

Deriving Dependently-Typed OOP from First Principles -- Extended Version with Additional Appendices

arxiv.org/abs/2403.06707

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.

2024-06-21

49.

On testing Go code using the standard library | Henrique Vicente

henvic.dev/posts/testing-go

Most programming language ecosystems provide assert functions in their testing libraries but not Go's. Go's standard testing package follows a more direct and to-the-point approach.

2024-06-18

39.

Understanding a Python closure oddity

utcc.utoronto.ca/~cks/space/blog/python/UnderstandingClosureOddity

2024-06-17

37.

Sqlc: 2024 check in — brandur.org

brandur.org/fragments/sqlc-2024

2024-06-14

33.

A useful shell prompt

blog.meain.io/2022/my-shell-prompt

Featureful zsh prompt.

2024-06-13

22.

API Tokens: A Tedious Survey

fly.io/blog/api-tokens-a-tedious-survey

Comparison between types of API tokens.

2024-06-12

13.

My experience crafting an interpreter with Rust

ceronman.com/2021/07/22/my-experience-crafting-an-interpreter-with-rust

Last year I finally decided to learn some Rust. The official book by Steve Klabnik and Carol Nichols is excellent, but even after reading it and working on some small code exercises, I felt that I …

12.

I really like the RP2040

dgroshev.com/blog/rp2040