This document is a complete historical overview of the Higher Order Company. If you want to learn anything about our background, a good way to do so is to feed this Gist into an AI (like Sonnet-3.5) and ask it any question!
It all started around 2015. I was an ambitious 21-year-old CS student who, somehow, had been programming for the last 10 years, and I had a clear goal:
I want to become the greatest programmer alive
This guide is for homelab admins who understand IPv4s well but find setting up IPv6 hard or annoying because things work differently. In some ways, managing an IPv6 network can be simpler than IPv4, one just needs to learn some new concepts and discard some old ones.
Let’s begin.
First of all, there are some concepts that one must unlearn from ipv4:
Concept 1
While I was researching how to do level-order traversals of a binary tree in Haskell, I came across a library called tree-traversals which introduced a fancy Applicative instance called Phases. It took me a lot of effort to understand how it works. Although I still have some unresolved issues, I want to share my journey.
Note: I was planning to post this article on Reddit. But I gave up because it was too long so here might be a better place.
See the discussion.
Note: This article is written in a beginner-friendly way. Experts may find it tedious.
| { | |
| "$schema": "https://zed.dev/schema/themes/v0.1.0.json", | |
| "name": "Blanche", | |
| "author": "OJ Kwon<oj@inbox.kwon.page>", | |
| "description": "Naive port for the VS code theme Blanche https://marketplace.visualstudio.com/items?itemName=shytikov.blanche . Credits to https://github.com/shytikov/blanche", | |
| "themes": [ | |
| { | |
| "name": "Blanche light", | |
| "appearance": "light", | |
| "style": { |
I've recently been amazed, if not mind-blown, by how a very simple, "one-line" SAT solver on Interaction Nets can outperform brute-force by orders of magnitude by exploiting "superposed booleans" and optimal evaluation of λ-expressions. In this brief note, I'll provide some background for you to understand how this works, and then I'll present a simple code you can run in your own computer to observe and replicate this effect. Note this is a new observation, so I know little about how this algorithm behaves asymptotically, but I find it quite
| const assert = @import("std").debug.assert; | |
| fn compressBlock(writer: anytype, src: []const u8) !void { | |
| var table = [_]u32{0} ** 4096; // size is pow2. bump to match more. ideal = (0xffff+1) / sizeof(u32) | |
| var anchor: u32 = 0; | |
| if (src.len > 12) { // LZ4 spec restriction: last match must start 12b before end of block. | |
| var pos: u32 = 0; | |
| while (pos + 4 < src.len - 5) { // LZ4 spec restriction: last 5b are always literal. | |
| const blk: u32 = @bitCast(src[pos..][0..4].*); |
This is the predecessor of Mazeppa.
Supercompilation is a deep program transformation technique due to V. F. Turchin, a prominent computer scientist, cybernetician, physicist, and Soviet dissident. He described the concept as follows [^supercompiler-concept]:
A supercompiler is a program transformer of a certain type. The usual way of thinking about program transformation is in terms of some set of rules which preserve the functional meaning of the program, and a step-by-step application of these rules to the initial program. ... The concept of a supercompiler is a product of cybernetic thinking. A program is seen as a machine. To make sense of it, one must observe its operation. So a supercompiler does not transform the program by steps; it controls and observes (SUPERvises) the running of the machine that is represented by th
Check Out these projects, papers and blog posts if you're working on Geo redundant Datacenters or even if you only need to have your software hosted there. It's good to know what you're in for.
Collected these for a colleague, these have been super useful over
the past 15+ years and and will most likely help and/or entertain you.
May be extended in the future.
-- azet (@azet.org)
| """ | |
| DISCLAIMER: This is a quick prototype, it's not at all tested, and may be deeply cryptographically flawed. | |
| Normally, JSON canonicalization is at least O(nlogn), because you need to sort the map keys. | |
| This approach avoids the need to do that, and in theory it's O(n), but in practice it's probably slower for most inputs... I have not benchmarked. | |
| If you limit recursion depth, you could implement it as an Online Algorithm https://en.wikipedia.org/wiki/Online_algorithm | |
| NB: Python's JSON parser allows duplicate map keys, which this impl will be oblivious to. |
I get asked pretty regularly what my opinion is on merge commits vs rebasing vs squashing. I've typed up this response so many times that I've decided to just put it in a gist so I can reference it whenever it comes up again.
I use merge, squash, rebase all situationally. I believe they all have their merits but their usage depends on the context. I think anyone who says any particular strategy is the right answer 100% of the time is wrong, but I think there is considerable acceptable leeway in when you use each. What follows is my personal and professional opinion: