steen's burrow

Enumerate your logs

steen — Sun, 01 Feb 2026 00:00:00 +0000

I'm working on my Soulseek client snus</a> (named in honour of nicotine+</a>), which is a Gleam application targeting the BEAM and an attempt to learn some things about OTP. I've also been working on some new projects at work that use structured logging and "audit logging" using structured fields, and I like the pattern! I'd like snus to have structured logs as well. How do I do it?</p>

A crash introduction to Gleam</h2>

Gleam</a> is a very nice programming language with a mauve pink smiling star as a mascot. I like it a lot! I think Gleam is best described as a functional-first ML-like (as in OCaml and SML) language with a Rust-like syntax. In as few words as I can muster:</p>

It uses +</code> for integer addition and +.</code> for float addition like OCaml does, which makes me happy.</li>
</ul>

Structured logging</h2>
Go has a structured logging library</a> whose functions take an unstructured message, and then pairs of (string, any)</code> as varargs. I don't remember which library my workplace uses for structured logging in Python, but I'm sure it has a similar structured.</p>
Gleam does not have a dictionary/hash(map)/object literal: it handles dicts just like Elm</a>. You can make a dict from a List</code> of #(key, value)</code> if you want, so if you wanted to reproduce slog</code> in Gleam you'd have a print(level: LogLevel, data: List(#(String, String)))</code> function. There's a few</a> structured</a> logging</a> libraries</a> on the Gleam package index</a> that fit the bill, but I didn't like any of them and I was wondering how I could reconsider that approach.</p>
Gleam doesn't have a built-in syntax for booleans; Bool</code> is a "custom type" like any other that could just as easily be defined in a library:</p>
type</span> Bool {</span></span>
  True</span></span>
  False</span></span>
}</span></span></code></pre>
Booleans could just as well be reprenented as the strings "true"</code> and "false"</code>, but languages like Gleam and OCaml and Rust and C# and Java and Go choose to represent booleans as their own type. How many states could a String</code> have compared to a Bool</code>? Would you say, ten million</a>?</p>
Now think about your application's logs. How many states that are meaningful enough to be logged does your service have? Can you enumerate all of them? Can you gracefully handle the failures? Does the user need to know about it? Is it useful for debugging? Will the log message have to be localized at some point?</p>
There's several</a> structured</a> logging</a> libraries</a> available</a> in the Gleam package registry. Gleam is a new language whose library ecosystem is still growing, none of these libraries seem to be leading the pack, so I'm not sure I should be committing to any of them. Instead I added a logging</code> module containing a Log</code> variant that contains all the types of things I want to be logging in the application, along with some data that I think will be useful to debug any problems. This will let me easily switch logging implementation in the future, but I think it's also a good pattern to keep in my toolbox.</p>
pub type</span> Log {</span></span>
  PeerAlreadyConnected(</span></span>
    conn_type: ConnectionType,</span></span>
    ip: IP,</span></span>
    port: Int,</span></span>
  )</span></span>
  PeerViolatedConnectionOrder(</span></span>
    username: String,</span></span>
    message: String,</span></span>
  )</span></span>
  // ...</span></span>
}</span></span></code></pre>
Enumerating special cases in a program is a way to give them semantical meaning. I think logs can be as deserving of care and thought as much as the important part of our applications: maybe just the act of adding the failure case can give you a chance to think about it more carefully. Consider enumerating your logs.</p>



Building smaller Docker images faster
steen — Fri, 12 Dec 2025 00:00:00 +0000
I've been tasked (more or less) with building the first Go service at $DAYJOB</code>, which is almost exclusively a Python shop. Why Go of all languages? Well, some of my coworkers are big fans of the gopher, it's an easy language, it's attached to one of the big companies, and it's much faster than Python, so I feel more comfortable pushing for this rather than Rust or (sadly) Nix.</p>
The project that recently fell onto my lap is basically RCE-as-a-service, and it just so happens that one of the few languages</a> that I would feel comfortable letting users execute remotely on our servers has a Go implementation</a>, which is as good an excuse as any to take a break from the usual snekslop.</p>
I still haven't convinced anybody here to get on the Nix train, so after a short stint of building the project and the OCI images with a recursive cycle of Make and Nix, I breathed a heavy sigh and dropped it for Docker and Docker Compose, which is what we generally use here.</p>

  And just between you and me, I don't think we use them very well. CI is painfully slow and we all just kinda live with it because figuring out how the damn Dockerfile</code> works sucks even more.</p>

</aside>
Which is a shame, because Nix is pretty good at building OCI images. This is all the code you need to create a minimal image that contains only your service and nothing else, not even /bin/sh</code>.</p>
{</span> pkgs</span> ?</span> import</span> <nixpkgs></span> {} }:</span></span>
pkgs</span>.</span>dockerTools</span>.</span>streamLayeredImage</span> {</span></span>
  name</span> =</span> "</span>someimage</span>"</span>;</span></span>
  tag</span> =</span> "</span>latest</span>"</span>;</span></span>
  config</span>.</span>Cmd</span> =</span> [</span></span>
    "</span>${</span>pkgs</span>.</span>hello</span>}</span>/bin/hello</span>"</span></span>
  ]</span>;</span></span>
}</span></span></code></pre>
You can build that with nix-build docker-test.nix</code> and inside ./result</code> you'll find a script that generates the image's tarball. Load it up with ./result | docker load</code> and Docker will report a new image called someimage:latest</code> when you run docker image ls</code>. It's only 45.8MB, and most of that is taken up by glibc.</p>
But what if I told you that you can get more or less the same result with a simple Dockerfile</code> if you know what you're doing? Especially if you're building a static executable, which Go famously does (at least when you set CGO_ENABLED=0</code>) and if you're willing to sacrifice a few affordances. Who needs coreutils anyway?</p>
In this post I'll show you a few tricks I found while striving to make small and fast-building images. I'm not an expert in Docker by any stretch so maybe you know all of this stuff already, but perhaps you might learn something new.</p>
A barebones image</h2>
I'm using goose</code></a> for database migrations. I configured the docker-compose.yml</code> to run its container just after the database has started and before the actual service runs, and since it's a very small self-contained tool I figured I could try to make the image as small and quick to build as possible. Let me show you the relevant part of the docker-compose.yml</code> first:</p>
services</span>:</span></span>
  migrate</span>:</span></span>
    image</span>:</span> migrate:latest</span></span>
    pull_policy</span>:</span> build</span></span>
    build</span>:</span></span>
      context</span>:</span> https://github.com/pressly/goose.git#v3.26.0</span></span>
      dockerfile</span>:</span> $PWD/Dockerfile.migrate</span></span>
    environment</span>:</span></span>
      GOOSE_DBSTRING</span>:</span> postgresql://AzureDiamond:hunter2@db:5432/bobby</span></span>
      GOOSE_MIGRATION_DIR</span>:</span> /migrations</span></span>
      GOOSE_DRIVER</span>:</span> postgres</span></span>
    depends_on</span>:</span></span>
      db</span>:</span></span>
        condition</span>:</span> service_started</span></span>
    volumes</span>:</span></span>
      -</span> ./migrations:/migrations</span></span></code></pre>
The build.context</code> parameter</a> specifies the "set of files" that are available from the host while building a Docker image. It's the parameter that you pass after docker build</code>, generally .</code> (the PWD). Here I specified a GitHub URL with a tag, so when I'm referring to .</code> in the Dockerfile</code> above I get the root of the goose</code> project on that tag's commit. I didn't know Docker could do that!</p>
The build.dockerfile</code> path includes $PWD</code> because even if Docker itself can refer to Dockerfiles outside of its context, Docker Compose apparently can't</a> unless you specify it as an absolute path. I think this will break if you try to run docker compose</code> from another directory, but it's good enough for now.</p>
Now let's take a look at the Dockerfile</code> itself:</p>
FROM</span> golang:1.25-alpine3.23 </span>AS</span> builder</span></span>
</span>
WORKDIR</span> /build</span></span>
</span>
ARG</span> CGO_ENABLED=0</span></span>
</span>
ARG</span> GOCACHE=/root/.cache/go-build</span></span>
ARG</span> GOMODCACHE=/root/.cache/go-mod</span></span>
</span>
RUN</span> --mount=type=cache,target=/root/.cache/go-build \</span></span>
  --mount=type=cache,target=/root/.cache/go-mod \</span></span>
  --mount=type=bind,source=.,target=/build \</span></span>
  go build -tags=</span>'no_clickhouse no_libsql no_sqlite3 no_mssql no_vertica no_mysql no_ydb'</span> -o /goose ./cmd/goose</span></span>
</span>
FROM</span> scratch</span></span>
</span>
COPY</span> --from=builder /goose /goose</span></span>
</span>
CMD</span> [</span>"/goose"</span>, </span>"up"</span>]</span></span></code></pre>
A few things to note:</p>

I used the Alpine image for Go because it's the smallest and it includes everything I need to build the tool.</li>
I set CGO_ENABLED=0</code> to ensure that the executable only builds with the Go toolchain and does not link to libc. According to the docs</a>, The cgo tool is enabled by default for native builds on systems where it is expected to work</em> so you have to take extra care to disable it if you don't want or need it.</li>
I set GOCACHE</code> and GOMODCACHE</code> (docs</a>) to a known location to ensure that I can take advantage of cache mounts</a> on subsequent rebuilds. Admittedly this is not very useful for an external tool that I'm only expecting to build once but hey, every little bit helps.</li>
Instead of ADD</code>ing or COPY</code>ing the package's source I bind mounted</a> it to the workdir. This should make it a bit faster because it avoids an extra copy into the build container.</li>
FROM scratch</code> defines a second build stage</a> that ensures any artifacts from the actual build are discarded. scratch</code></a> is the null image.</li>
</ul>
The result is an image with one layer containing one file that builds, loads and boots extremely fast and is only *chef's kiss*</em></small> 15.9MB in size. Not too bad!</p>
</p>
The build context</h2>
Earlier I mentioned the build context. Keeping it small</a> is important because Docker copies all files available in the build context to the builder</a> every time you run a docker build</code>, so if you have lots of files in your repo that you don't need to build the image you'll probably want to exclude them. The way you do that is by keeping a .dockerignore</code> file alongside your Dockerfile</code>.</p>
I have to stress one point: the build context includes everything</strong> inside the directory you run docker build</code> from unless it's listed in .dockerignore</code>. I thought some obvious things like .git</code> would be excluded by default, but a quick test disproved that:</p>
FROM</span> busybox</span></span>
WORKDIR</span> /</span></span>
COPY</span> . ./</span></span>
CMD</span> []</span></span></code></pre>
Try saving that file as Dockerfile.test</code> in one of your repos, build it with docker build -f Dockerfile.text -t build-context .</code>, open a shell with docker run --rm -it build-context /bin/sh</code> and run find</code>. Everything's in there: .git</code>, .jj</code>, the Dockerfile.test</code> itself, and all the rest of the build artifacts and assorted junk you have accumulated in your project directory. Ignoring them won't make your images smaller, but it might make the build quicker.</p>
# .dockerignore</span></span>
.*</span></span>
</span>
Dockerfile*</span></span>
docker-compose.yml</span></span>
</span>
# ...</span></span></code></pre>Granular layers</h2>
Splitting and ordering layers</a> is probably the most well-known and obvious Docker build time optimization there is, but it doesn't hurt to mention. This is the Dockerfile</code> for the service I'm building:</p>
FROM</span> golang:1.25-alpine3.23 </span>AS</span> builder</span></span>
</span>
WORKDIR</span> /build</span></span>
</span>
ARG</span> CGO_ENABLED=0</span></span>
</span>
ARG</span> GOCACHE=/root/.cache/go-build</span></span>
ARG</span> GOMODCACHE=/root/.cache/go-mod</span></span>
</span>
RUN</span> --mount=type=cache,target=/root/.cache/go-build \</span></span>
  --mount=type=cache,target=/root/.cache/go-mod \</span></span>
  go install github.com/DataDog/orchestrion@latest</span></span>
</span>
RUN</span> --mount=type=bind,source=go.mod,target=go.mod \</span></span>
  --mount=type=bind,source=go.sum,target=go.sum \</span></span>
  --mount=type=cache,target=/root/.cache/go-build \</span></span>
  --mount=type=cache,target=/root/.cache/go-mod \</span></span>
  go mod download</span></span>
</span>
RUN</span> --mount=type=bind,source=go.mod,target=go.mod \</span></span>
  --mount=type=bind,source=go.sum,target=go.sum \</span></span>
  --mount=type=cache,target=/root/.cache/go-build \</span></span>
  --mount=type=cache,target=/root/.cache/go-mod \</span></span>
  --mount=type=bind,source=internal,target=internal \</span></span>
  --mount=type=bind,source=cmd,target=cmd \</span></span>
  --mount=type=bind,source=orchestrion.tool.go,target=orchestrion.tool.go \</span></span>
  orchestrion go build -o server ./cmd/server</span></span>
</span>
FROM</span> alpine:3.23 </span>AS</span> prod</span></span>
</span>
WORKDIR</span> /app</span></span>
</span>
COPY</span> --from=builder /build/server .</span></span>
</span>
ENTRYPOINT</span> [</span>"/app/server"</span>]</span></span></code></pre>
You can see all the bind and cache mount tricks from earlier, not much has changed. I'm installing orchestrion</code></a> (a great tool to bloat up your binary size if you ever feel like it) early because that's the least likely to change. After that I bind mount go.mod</code> and go.sum</code> and only download the dependencies, because that's the step that generally takes the most time and dependencies change less often than code. Only at the end do I bind mount the package directories and build the server.</p>

  I opted for good ol' Alpine for the base final image. It only adds a couple more MBs and I'm sure whoever will eventually have to shell into a prod container will appreciate having something to work with.</p>

</aside>
You can iterate on this by changing one of the relevant files and ensuring that all the previous steps are marked as CACHED</code> on the next docker build</code>. Again, this won't save you space but it'll save you a lot of time while iterating.</p>
Conclusions</h2>
Summing up:</p>

Read the Optimize cache usage in builds</a> page in the Docker documentation, and maybe take a look at the rest while you're there.</li>
Split, merge and order layers according to how often you expect them to be rebuilt. Directives like ENV</code>, ARG</code> and WORKDIR</code> should go before everything else.</li>
Use multi-stage builds</a> to shrink the final image size. Consider if you can get away with using scratch</code>, busybox</code> or alpine</code> for the final image.</li>
If your project contains multiple separate applications (for example a backend and a frontend) you can create separate build stages for each of them, and then copy the results into a final image. Stages that don't depend on each other are built in parallel if you're using BuildKit</a>, and you can do all sorts of tricks</a> with multi-stage builds to ensure your CPU runs hot all the time.</li>
Add a .dockerignore</code> to your project, and make sure to put .git</code> in there if you don't need it.</li>
Try to set up cache mounts to make sure dependencies and intermediate build artifacts are persisted across builds. Some CI services (GitHub actions, apparently) even let you set up external caches</a>.</li>
Try to use bind mounts instead of COPY</code>ing source files into the builder. Bind mounts are usually read-only, but you can make them read-write if you really need to.</li>
I didn't use it in my Dockerfile</code>s, but apparently you should be using ADD</code> for downloading files, archives or Git repos during your build. The docs</a> mention that COPY</code> should mostly be used for copying files between stages or for files you need in your final image, and for the rest you should try to use bind mounts.</li>
Use smaller base images when possible and if you really</em> have to install stuff with apt</code> you should make an intermediate image and upload it to your container repository of choice so your poor runners don't have to hammer Debian's mirrors every single time you push.</li>
</ul>
One last trick before the post is over: I just discovered that Docker Compose has a watch mode</a> that tracks changes in the build context and rebuilds (or does other things with) your image on every change. Nice!</p>


Hacking on the reMarkable 2
steen — Sun, 30 Nov 2025 00:00:00 +0000
Since last Wednesday, I am the proud owner of a reMarkable 2</a>. There was a black friday discount and some refurbished deals that meant I could get the tablet, the Marker Plus and the book cover for a little over the asking price of the base tablet and marker so I decided to take advantage of it.</p>
A short review</h2>
The reMarkable is marketed as a distraction-free reading and writing device, and I can confirm that it excels at writing. The friction of the stylus on the epaper display feels just right, the latency is low enough that it resembles writing with ink that takes an instant to set on the page, and you can customize the brush enough to achieve whatever effect you want. I haven't written this much since I was in high school and I think I kind of missed it.</p>
The Marker Plus includes an eraser on the other end of the stylus; if you're thinking of getting one of these things I'd recommend spending a bit more to get this version of the marker because I can imagine erasing things to get very annoying. The other options you have for erasing are a two-tap gesture to undo the last stroke (which I use a lot to delete the last letter if it didn't turn out right), and a selection eraser tool which is useful for deleting entire paragraphs.</p>
The touch gestures are not great: they don't always register and they always need a bit more pressure than you might expect. Navigating with the stylus is much more pleasant, but some things (turning pages) you can only do by swiping. The reMarkable 1 used to have three physical buttons below the screen, and I wish the second iteration had kept those.</p>
Reading PDFs is serviceable (papers are kind of annoying to read because you have to zoom in just a little to read comfortably) and I haven't tested ebooks yet.</p>
Obviously the reMarkable has its own subscription service</a> called Connect that unlocks some useful features like unlimited cloud storage (the free plan seems to delete files from the cloud after 50 days of inactivity), editing documents in the companion desktop and mobile apps, "premium templates", screen sharing, an extended warranty, and a few other things.</p>
At $29.90 a year honestly it's not such a bad deal, and even the free plan's limitations are not too bad. The signup procedure for my.reMarkable deceptively funnels you into signing up for a 50 day trial and I couldn't find a comprehensive page that shows what you get without paying, but if you don't give up your payment info you'll find that you can still see your cloud synced files and enable the Google Drive/Dropbox/OneDrive integration.</p>
Reading sheet music</h2>
One of the reasons why I wanted to get an epaper tablet was to read sheet music. I sing in a choir and we have a concert coming up during which we won't be allowed to use regular tablets due to the backlighting, and it felt like the perfect excuse to get one of these things to play with.</p>
Reading sheet music is not great on the reMarkable. The refresh rate while turning pages is serviceable, and annotating PDFs with the stylus is a great experience, but there's a few features I have gotten used to on MobileSheets on my tablet that the reMarkable does not support:</p>

Cropping pages individually. The document viewer lets you zoom in, but it's imprecise and it gets applied to the whole document, and I don't think the zoom level and offset is saved when switching to another document.</li>
Half-page turning. When you turn a page in MobileSheets, you can set it to overlay half of the next page on the current one so you can follow the last bar while checking what's coming up next.</li>
Turning pages with a single touch. I mentioned that I don't really like the swipe gestures and I'm not looking forward to fighting gesture recognition while trying to turn a page during a performance.</li>
Library management. The reMarkable only displays a PDF's filename, but I like to keep my scores indexed by both name and composer/arranger and I'd much rather use metadata rather than a naming scheme to manage them.</li>
Setlists. During a performance you don't want to be searching for the next piece and most pieces are going to be shared between many concerts. While you can organize documents by folder, duplicating a score in many different folders is not ideal.</li>
</ul>
These features are non-negotiable for a good music sheet reader and the reMarkable's stock software is not up to par. When I bought the reMarkable 2 I figured I could just</em> write my own PDF reader and manager for it and work these features into it.</p>
Running homebrew software</h2>
The reMarkable is a computer like any other, so I believe that since I bought it, I own it, and I should be able to run whatever software I want on it. On this front I have to give credit where it's due. reMarkable the company could've easily locked the device down to get you to pay for its subscription and buy new iterations of the device when they end support for the old ones, but if you go into the Settings > Help > Copyright and licenses</strong> menu you'll find a paragraph explaining that to comply with the GPLv3 the end user should be able to modify the software that's running on the device, and below that a short explaination on how to SSH into the reMarkable as root</code>.</p>
At first glance the reMarkable has an active homebrew software ecosystem too. There's a community-maintained wiki</a> with guides on how to install toltec (a package manager)</a> and developing software</a> for the device. After I unpacked the tablet I was eager to get Toltec running and install some software, but...</p>
</p>
Toltec has strict bounds</a> on which versions of the reMarkable OS it supports. After unboxing and setting up my reMarkable 2 I ended up on version 3.23.0.64, which is way beyond what Toltec supports. Am I cooked? Well, the guide mentions that you can</em> downgrade to a different OS version</a>, so maybe...</p>

Caveat for downgrading from 3.11.2.5 or greater to a version less than 3.11.2.5</a></h3>
If your reMarkable device is at or above 3.11.2.5 and you want to downgrade to a version below 3.11.2.5, codexctl cannot do this currently. Please refer to #95 (comment)</a> for manual instructions.</p>
</blockquote>
Ok, looks like you can do it, but if you want to downgrade that far you're looking for trouble. But why do I have to do this, have the maintainers simply lost interest? Let's take a look at the GitHub issue</a> that tracks newer OS builds support.</p>
</p>
Ah. And what exactly is rm2fb</a> then?</p>
</p>
Ok. I don't understand why you'd need to use shared memory and message queues to draw to a framebuffer, but maybe the rest of the README will have more clues on that. If you scroll down to the FAQ there's a helpful link called how does rm2fb work?</a></p>

The server process will rely on using functions from either xochitl</code> or remarkable-shutdown</code> but those processes don't actually run. We use LD_PRELOAD to take over the process, like LD_PRELOAD=rm2fb.so xochitl</code> and then we use our own main() func but call into the APIs we need to 1) start the SWTCON threads and 2) send updates. If we go server model, this only needs to happen once (instead of each application doing this dance)</p>
</blockquote>
At this point we should talk about xochitl</code>.</p>
Proprietary software woes</h2>
xochitl</code> is the main application running on the reMarkable</a>, and it is proprietary software. Unfortunately it also makes for the only documentation the homebrew community has for driving the framebuffer that draws to the reMarkable's epaper display; the SDK</a> provided by reMarkable only supports Qt Quick</a> so if you don't want to use Qt or link to libqsgepaper.so</code> you're stuck with reverse engineering xochitl</code>.</p>
The reMarkable 1's display driver seems to have been completely reverse engineered, but not the reMarkable 2's (except for individual efforts, which I'll talk about later).
Most of the homebrew programs for the reMarkable are written to directly draw to the framebuffer, and they expect to interact with the reMarkable 1's framebuffer.</p>
rm2fb</code> comes in as a compatibility layer that allows programs that interact with the rm1's framebuffer to run on the rm2. Since the rm2's framebuffer driver had not been completely reverse engineered when this was developed, rm2fb</code> hooks into xochitl</code> and uses its code to interact with the framebuffer. This relies on rm2fb</code> knowing the offsets and the signatures of those functions into the xochitl</code> binary, so obviously when the OS build changes and xochitl</code> is upgraded, those offsets and signatures are invalidated and rm2fb</code> will stop working until somebody works those out again.</p>
Freeing the reMarkable 2 from Xochitl</h2>
At this point I had already loaded up xochitl</code> into Ghidra and I was starting to figure out how the framebuffer is used inside it. I mean, how hard could it be?</p>
</p>
I mostly searched for calls to ioctl</code> and quickly made some good progress. Then I figured that if this was so easy somebody else with more experience than me must have have already done it, so I did some more searching.</p>
rm2fb</code>'s FAQ section also includes another link, what about implementing an open source SWTCON?</a> which links to a repository containing a version</a> of rm2fb</code> that works on newer OS build versions, and an initial implementation</a> of a reMarkable 2 display driver that only relies on xochitl</code> for some things. I also joined the reMarkable community Discord server to see if I could glean more info. There were some posts by timower</a> (the owner of the rm2-stuff</code> repo) talking about the problems they faced while reverse engineering it.</p>
</p>
A few years later, Mattéo Delabre</a> shared a link to a repository</a> containing a C++ driver for the reMarkable 2 display that did not rely on on xochitl</code>, though development seems to have stagnated around 2022. Then a few months ago, jakubvf</a> shared their own implementation</a> of a rm2 display driver in Zig with support for SDL3.</p>
Neither of these efforts seem to have caught on, but the Toltec maintainers are working on support for newer OS build versions that can safely be downgraded to from 3.23.* so I hope that in the near future I'll be able to install Toltec on my device without messing too much with it.</p>
As for me, I started my yak shaving chain to build the music sheet reader by reimplementing waved/dazed</a> in my poison of choice, Rust. I'm not going to finish this program in time for the concert but that's ok.</p>
This is where I would've liked to include a section on how you can drive the reMarkable 2's display with just a few syscalls but I'm still figuring that out! This post has already turned out to be longer than I thought so I'll leave that stuff for a possible future post on how to write software for the reMarkable 2.</p>
Lastly, I'd like to thank the reMarkable hacking community for all their work on reverse engineering and developing software for it, because I would definitely have regretted this purchase if it weren't for their efforts.</p>
</p>


My Immich setup feat. NixOS
steen — Fri, 03 Oct 2025 00:00:00 +0000
Immich reached a stable release!</a> I started using it several months ago and I've been having a very pleasant experience with it, so I figured I could write a few lines about it.</p>
Immich</a> is an open source self-hosted replacement for Google Photos and other similar paid services. It has a very polished web UI and mobile apps. This is what it looks like:</p>
</p>
Basically you slap it on your home server, upload your photos, and you get all the good parts of a photo hosting service without selling your soul and throwing away your privacy! For free!!</em> Free unless you're counting hardware and electricity bills that is, but then again, once you have a home server to run Immich you can use it to run all</a> sorts</a> of</a> cool</a> software</a>.</p>
It is licensed under the AGPL and the people behind the company that maintains it</a> seem to have a strong commitment to privacy and open source. Immich uses several (optional) ML-powered features like facial recognition, contextual search, and duplicate detection, all of which run locally. (This is what I like to call "one of the few useful uses of AI."</em>) As far as I can tell, Immich does not "phone home" or contact the external world on its own.</p>
If you snoop around on the website you'll see a "Purchase</a>" link, and you'd be forgiven for thinking that this is a Freemium™ product that paywalls some features. But it's not! If you "buy" Immich all you get is a badge showing that you're a supporter on the web UI. You'll notice that I have the badge in my screenshot: I was so impressed with Immich after using it for a few weeks that I figured I should show my support in some way. For the 2.0.0 release they've also started selling some branded clothes and an actual demo disk</a> on their store, which I think is just lovely.</p>
(If this sounds a lot like shilling, I can assure you I'm not related to the Immich project or FUTO in any way. I'm just a happy user.)</p>
Why I'm running Immich</h2>
The short answer is I like self-hosting and open source software and I don't like Google. I'm self-hosting a bunch of other things, some of which I linked above.</p>

  Actually I'm not running Jellyfin</a> yet, but I'd like to do so in the near future. I'm planning to upgrade the mainboard of my Framework 13" laptop</a> and place the old one in a case</a> which will go on my home "rack", and take some of the load off my Raspberry Pi. That poor thing can't handle transcoding movies.</p>
Also, my partner wants me to set it up so they can watch the movies by Nanni Moretti</a> I have sitting on my home server when they're not at my place. But I'm getting ahead of myself.</p>

</aside>
The long answer involves several old hard drives with photos recovered from dead phones and busted cameras, and still-working phones bursting with photos. The latter are my partner's and my mother's phones. Both of them were often complaining about how they couldn't download a file or take another photo because their phones' storage had run out of space, and I, the most Computer Person of the family, would have to regularly swoop in and save the day by deleting some old files and apps they weren't really using. The old hard drives are my own, and I wasn't keen on losing those old memories.</p>
All of us had photo library problems, and something had to be done.</p>
Setting up Immich on NixOS</h2>
...is really easy. On the Lobste.rs thread</a> of the announcement, Michael stapelberg</a> commented that it's as easy as adding this snippet to your NixOS config:</p>
{</span></span>
  services</span>.</span>immich</span> =</span> {</span></span>
    enable</span> = true;</span></span>
    host</span> =</span> "</span>photos.example.ts.net</span>"</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
My setup</a> is a bit more complicated than that. First of all I dedicated a spare hard drive to it, which is mounted to Immich's service directory. The wantedBy</code> rule ensures that Immich can only run after the drive has been mounted.</p>
{</span></span>
  systemd</span>.</span>mounts</span> =</span> [</span></span>
    {</span></span>
      type</span> =</span> "</span>ext4</span>"</span>;</span></span>
      what</span> =</span> "</span>/dev/sdb2</span>"</span>;</span></span>
      where</span> =</span> "</span>/var/lib/immich</span>"</span>;</span></span>
      wantedBy</span> =</span> [</span></span>
        "</span>immich-server.service</span>"</span></span>
      ]</span>;</span></span>
    }</span></span>
  ]</span>;</span></span>
}</span></span></code></pre>
Immich has several features that depend on machine learning</a>, which is cool but definitely not something the Raspberry Pi I'm running it on can handle! Luckily for the poor Pi, you can run the ML service on another computer</a> and configure Immich to use it, so this is what my actual Immich config looks like:</p>
{</span></span>
  services</span>.</span>immich</span> =</span> {</span></span>
    enable</span> = true;</span></span>
    host</span> =</span> "</span>0.0.0.0</span>"</span>;</span></span>
    openFirewall</span> = true;</span></span>
    machine-learning</span>.</span>enable</span> = false;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
The ML service runs on my much beefier desktop. NixOS's Immich module doesn't currently support</a> running the ML service separately from Immich, so I had to write my own module for this. You can find the full module here</a> (which someday I will try to upstream), but just to give you an idea:</p>
{</span></span>
  # module options elided for brevity</span></span>
</span>
  config</span> =</span> lib</span>.</span>mkIf cfg</span>.</span>enable</span> {</span></span>
    networking</span>.</span>firewall</span>.</span>allowedTCPPorts</span> =</span> [</span> cfg</span>.</span>port</span> ]</span>;</span></span>
</span>
    systemd</span>.</span>services</span>.</span>immich-ml</span> =</span> {</span></span>
      after</span> =</span> ["</span>network.target</span>"]</span>;</span></span>
      wantedBy</span> =</span> ["</span>multi-user.target</span>"]</span>;</span></span>
      environment</span> =</span> {</span></span>
        IMMICH_HOST</span> =</span> cfg</span>.</span>host</span>;</span></span>
        IMMICH_PORT</span> =</span> toString</span> cfg</span>.</span>port</span>;</span></span>
        MACHINE_LEARNING_CACHE_FOLDER</span> =</span> "</span>/var/cache/immich-ml</span>"</span>;</span></span>
        IMMICH_MACHINE_LEARNING_WORKERS</span> =</span> toString</span> cfg</span>.</span>workers</span>;</span></span>
        IMMICH_MACHINE_LEARNING_WORKER_TIMEOUT</span> =</span> toString</span> cfg</span>.</span>workerTimeout</span>;</span></span>
        MPLCONFIGDIR</span> =</span> "</span>/var/lib/immich-ml</span>"</span>;</span></span>
      }</span>;</span></span>
      serviceConfig</span> =</span> {</span></span>
        ExecStart</span> =</span> "</span>${</span>lib</span>.</span>getExe cfg</span>.</span>package</span>}</span>"</span>;</span></span>
        StateDirectory</span> =</span> "</span>immich-ml</span>"</span>;</span></span>
        CacheDirectory</span> =</span> "</span>immich-ml</span>"</span>;</span></span>
        DynamicUser</span> = true;</span></span>
        # some hardening and nvidia-related options...</span></span>
      }</span>;</span></span>
    }</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
  I never got it to use my GPU for the ML tasks. There is an issue on nixpkgs</a> about this which was closed 2 weeks ago, so I'll have to check the next time I update my flake inputs.</p>
And by the way, if you go look at the service definition in my flake you'll see that it's supposed to be a socket-activated service, but I'm not sure that it's working as it's supposed to. Someone who is good at the systemd please help me fix this. my family is dying</del></p>

</aside>
After this you can go on Immich and navigate to Administration</strong> > Settings</strong> > Machine Learning Settings</strong> to add the URL of your ML worker machine.</p>
I also set up backups. Backups are super important because I'm not the only user. My partner would be quite sad if I lost their photos due to a busted drive.</p>
I'm using restic</a> and backing up to Backblaze B2</a> and another drive, for safety. In my configuration I'm using a helper module I wrote that sources the secrets, repository, and password from files set up by sops-nix</a>, but this is the moral equivalent:</p>
{</span></span>
  services</span>.</span>restic</span>.</span>backups</span>.</span>immich</span> =</span> {</span></span>
    paths</span> =</span> [</span></span>
      "</span>/var/lib/immich</span>"</span></span>
    ]</span>;</span></span>
    # The environment file should contain:</span></span>
    # AWS_ACCESS_KEY_ID=<key_id from the B2 bucket></span></span>
    # AWS_SECRET_ACCESS_KEY=<key_secret from the B2 bucket></span></span>
    environmentFile</span> =</span> "</span>/super/secret/environment-file</span>"</span>;</span></span>
    passwordFile</span> =</span> "</span>/super/secret/password-file</span>"</span>;</span></span>
    repository</span> =</span> "</span><repository>/<bucket name></span>"</span>;</span></span>
    timerConfig</span> =</span> {</span></span>
      OnCalendar</span> =</span> "</span>daily</span>"</span>;</span></span>
      Persistent</span> = true;</span></span>
    }</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
Finally, I used a Tailscale Funnel</a> to expose it to the internet, so that my relatives could use it without setting up Tailscale on their devices. I wrote a very simple service to take care of this:</p>
{</span></span>
  systemd</span>.</span>services</span>.</span>tailscale-funnel-immich</span> =</span> {</span></span>
    description</span> =</span> "</span>Tailscale Funnel forwarding for Immich</span>"</span>;</span></span>
</span>
    # https://old.reddit.com/r/Tailscale/comments/ubk9mo/systemd_how_do_get_something_to_run_if_tailscale/jia3pwn/</span></span>
    after</span> =</span> [</span></span>
      "</span>sys-subsystem-net-devices-tailscale0.device</span>"</span></span>
      "</span>tailscaled.service</span>"</span></span>
      "</span>immich-server.service</span>"</span></span>
    ]</span>;</span></span>
    wantedBy</span> =</span> [ "</span>multi-user.target</span>" ]</span>;</span></span>
</span>
    serviceConfig</span>.</span>ExecStart</span> =</span> "</span>${</span>lib</span>.</span>getExe config</span>.</span>services</span>.</span>tailscale</span>.</span>package</span>}</span> funnel </span>${builtins.</span>toString</span> config</span>.</span>services</span>.</span>immich</span>.</span>port</span>}</span>"</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
And that's it! I've only ever had two issues with this setup.</p>

Every once in a while, the Tailscale session on my Pi expires and that makes the funnel inaccessible... I should probably set up some sort of notification for that.</li>
I don't run upgrades on the Pi very often, so I ran into a migration issue</a> that only happened if you skipped versions between v1.132.3 and v1.137.0. To fix it I had to pin a version of nixpkgs that packaged an intermediate version of Immich, deploy it on the Pi, wait for it to migrate, and then upgrade again to the latest version.</li>
</ul>
Overall it's been a very low maintenance setup.</p>
Using Immich</h2>
I'm sure you could tell from the introduction of this post, but I think Immich is really good! My partner uploaded all their photos and they're very happy with it. Unfortunately at some point my mother caved in to the pressure and subscribed to Google One, and I still haven't bothered to talk her out of it.</p>
I have uploaded all of my photos to it, an archive going back to 2014. The web UI makes it easy and quick to scroll and jump around the timeline; it has brought me back to many good memories. I also like the actual "memory" feature which finds photos you took on the same calendar day the previous years and shows them on top of the gallery. I haven't used any software to organize my photos since Picasa</a> was still a thing. Immich made me remember how nice that can be.</p>
There's a lot of other things I enjoy so I'll quickly go through them in a list:</p>

The reverse geocoding features are fun and useful. I like how I can see all the places I've taken photos in plotted on a map, and it's helped me remember holidays and good restaurants.</li>
Maybe this tells you more about me than about Immich, but the contextual CLIP search</a> kinda feels like magic. I can just search for "cat" and it'll show me all the cat photos I've ever taken! Unbelievable.</li>
Facial recognition requires some manual fixing sometimes, but I like it! It's fun to see how my friends used to look like 8 years ago.</li>
You can share albums between different users and also create external links with an expiration date that allow anybody with the link to upload their photos. I used this a bunch of times to share photos with friends I went on vacation with.</li>
This is not exactly a feature of Immich itself, but I like that the team behind Immich shares the "cursed knowledge" they came across while building Immich on a page on the website</a>.</li>
</ul>
In conclusion: I think you should give Immich a try! Don't let big corporations use your memories as training data for their torment nexi. Take control of your data. There are alternatives for most of the services you use regularly and they're actually really nice. Support those instead of throwing money at a subscription service.</p>
Thank you for reading, have a song I like</a>.</p>


About this blog
steen — Wed, 01 Oct 2025 00:00:00 +0000
I just changed my blog's tech stack, so the time has come for me to write the obligatory meta-post about my blog.</p>
I spent thursday night setting up this blog again, throwing out my own Racket</a>-based static blog generator</a> and replacing it with Zola</a>. I'm not particularly happy about killing my generator, but it was either choosing an off-the-shelf option or reimplementing a parser for a Markdown-based Racket #lang</code> that let me escape to Racket in a similar way to Pollen</a> and rewriting my (admittedly not very long tail of) previous posts in this new language, and I wasn't making much progress on that front.</p>
Why throw out the old stack? Well, I had a few annoyances about how it worked. First of all, the Markdown library</a> I was using did not handle Markdown extensions like tables, and there wasn't a way I could plug into the parser to implement those or add custom elements such as Cool Bear's hot tips</em> from @fasterthanlime's blog</a>.</p>
Then there was the problem of footnotes: the library generates unstable IDs for footnotes, so every time I regenerated the blog every single ID would change, which was annoying and led me to this cycle of generating the blog, then manually git restore</code>ing every page that was not supposed to be touched by the change. It was all a bit laborious. I'd also like to implement footnotes in the sidebar, and again, the library made it all kind of tedious.</p>
These were not insurmountable problems. I could probably embed the library into the generator and hook into the SXML</a> emitter to change the output it produces. I just never felt like doing that. Maybe I just don't like working in Racket anymore because it's generally untyped and its typed variant</a> is excruciatingly slow and often very annoying to work with.</p>
It took me a few hours of work to get Zola running and redesign the blog. I wrote a custom template, changed all the fonts, finally added support for tags</a>, made sure that all the old posts would render correctly, and aliased all the old URLs to the new ones. Zola has a built-in server with live reload that made this process much quicker. It was all very easy.</p>
I went with Zola entirely based on vibes, but I think I like its approach. It tries to generalize some standard things you'd want in a blog into more powerful concepts: posts become a section with pages</a>, tags become one of many taxonomies</a> that the website can have. Just about every template is customizable. It looks very fast: my whole blog renders in a hundred milliseconds, which sounds about right. I also set up its premade GitHub Actions workflow for deploying the blog to GitHub pages.</p>
I can't say I enjoy</em> writing Tera</a> templates and this was one of the issues that made me procrastinate the switch to an off-the-shelf generator, but honestly, they're fine. The one thing I dislike is that they're orthogonal to the text they produce, so a few times during the template writing process I ended up with invalid HTML. I'm not happy about that, but sometimes you just have to compromise.</p>
I took some inspiration from Devine Lu Linvega's website</a> for the top bar. You can find the fonts that I used on the meta</a> page: I think they look nice.</p>
There are some things that I'd like to implement in the future:</p>

Footnotes in the sidebar, as I previously mentioned.</li>
Comments? I wouldn't want to use a third-party thing, especially not after I read that Disqus injects tons of ads into your page</a>, so maybe I'll hack some custom solution together.</li>
I had this idea that I could publish this blog as an AT proto</a> thing just because I think it would be cool, but that probably involves changing the whole stack again. Something to think about for the future.</li>
</ul>
In conclusion, hats off to Zola for making the migration process very painless, and I hope this improved process will make me more likely to write posts on here.</p>


The masculine urge to reinvent the wheel
steen — Tue, 30 Sep 2025 00:00:00 +0000
So I've been playing Baby Steps</a>. It's a game about walking up a mountain by putting one foot in front of the other, and in the process it explores masculinity and how hard it is to accept help from others. I find that I have a lot more in common with Nate, the game's coveralls-wearing manchild protagonist and player character, than I would like to admit.</p>
I'm a self-taught programmer. After failing to get into the product design course at the Politecnico di Torino I enrolled into CS at UniTo because I'd been dabbling in computers since I was a kid, and in programming in the years leading up to my graduation from a linguistic lyceum. I did not attend a single course of the CS program. I don't even know what the CS department looks like because I never set foot into it. I'd planned a trip to, of all places, an anime convention with some friends I had made on the internet, and the trip just happened to overlap with the first few days of courses at the university. After I came back from the convention I figured that ship had sailed and I would not be able to bear the shame of missing the first day of uni. In the mornings I would pretend to take the train to uni, and instead go walking in the woods around my town. I was not in a good place mentally.</p>
Nevertheless, I kept programming. Eventually my father figured out that I was not going to uni. He let me stay home for the rest of the year until I figured things out. I learned Elm and OCaml. The sabbatical year turned into two. I learned TypeScript and React and made some small websites. Now I had to find a job. I rewrote the imageboard that kickstarted my interest in programming in Ur/Web. On the cusp of the third year, I got hired at a consultancy agency by some kind people who were sort of amused by the way I told them about these projects.</p>
During this time I developed a narrative for myself to cling on to. That's what you have to do when you're in a bad spot; you tell yourself whatever horseshit you need to keep yourself sane. I convinced myself that I was better than the average programmer, and certainly better than the people who came out of uni having only taken a cursory glance at Java and C++. Not only that but I'd come all this way by myself, so I didn't need help from others. I was proud</em> of my skills and my self-reliance.</p>
That pride begat a lot of traits that I carry with me to this day. Sometimes I find it hard to ask for help, particularly when I'm already knee-deep into a problem. I refuse to use project templates. If a library gives me a problem I'd rather reimplement it myself from first principles than figuring out how to fix it upstream. I generally don't like working in other people's code. If I have to choose between using a library that would be completely fine for my purposes and reimplementing the parts I need myself, I'll choose the shortest route to yak shaving any day of the week.</p>
I'm a competitive yak shaver. I've been wanting to revamp this blog for a while, but I always get stuck on the part where I have to reimplement the markdown parser. The production-level ones are clearly not up to the task because they don't produce the HTML output that I want, and I think I could do better anyway. I burn out on my own projects on a regular basis. Thank fuck I can turn to videogames when that happens.</p>
Oh, right, videogames. Baby Steps. Where were we?</p>
Baby Steps is partly about learning to accept help. It's not easy to do that; you have to swallow your pride and accept that the help you're getting may not be in the form that you envisioned. It took me a long time to convince myself to use Zola</a> to set up this blog when I don't really like the templating language it uses and I know that I could just as well write my own static site generator with a principled templating language and blackjack and hookers, given enough time.</p>
But that's just the thing: time. I work a full-time job and I have many other things to think about other than implementing the perfect templating language. I don't have the energy to do all of that. And Zola is pretty damn good anyway.</p>
I think I need to learn to accept that compromises are good, actually. That I can't do everything myself. That I don't need to do everything myself. That other people's code is often better than my own, and that flawed code that exists is infinitely better than better code that doesn't. That I should be getting help in any way I can.</p>


Simple Python devshells with Nix and direnv
steen — Sat, 08 Jun 2024 00:00:00 +0000
In my last post, I mentioned I'm currently working at a Python shop. I'm also a huge fan of Nix, and I believe that a day may come when we can get rid of the messy deployment setup we use now and replace it with Nix, but it is not this day. Today I'm just gonna talk about how I stealthily manage my development environments for the Python projects at work with Nix and direnv, and how you could easily do the same.</p>
Who is this for?</h2>
You're running NixOS or nix-darwin or home-manager on your computer of choice or maybe you're just trying Nix out, and you just want to get things done at your job.</p>
You don't particularly care about building a reproducible derivation or an image that you can deploy with Nix.</p>
You don't want to spend too much time figuring out why psycopg or some other Python library you don't want to pick a fight with is not building in your current checkout of nixpkgs.</p>
You don't want to install multiple versions of Python on your machine or mess with the tooling that should take care of that for you.</p>
You want to keep things clean.</p>
What do we want?</h2>
Since this is a work project, let's talk requirements!</p>


We shouldn't make any changes to the repositories; we don't want to go around dropping files in every team's repos if they don't want to buy into the tooling.</p>
</li>

We don't have to go all-in on Nix. Debugging a failing build of a Python package for a repo we don't touch all that often sucks and it adds too much overhead.</p>
</li>

Related to the previous point, the setup should be very similar to the one your team members are using.</p>
</li>
</ul>
In short: don't rock the boat. There's a time and a place for introducing tooling, and it is not now. We just want a working setup that succeeds in providing a Python development environment, without littering our global environment.</p>
The flake</h2>
The flake where I keep my dev environments looks kind of like this:</p>
{</span></span>
  inputs</span> =</span> {</span></span>
    nixpkgs</span>.</span>url</span> =</span> "</span>github:NixOS/nixpkgs</span>"</span>;</span></span>
    flake-utils</span>.</span>url</span> =</span> "</span>github:numtide/flake-utils</span>"</span>;</span></span>
  }</span>;</span></span>
</span>
  outputs</span> =</span> {</span> self</span>,</span> nixpkgs</span>,</span> flake-utils</span> }:</span></span>
  	flake-utils</span>.</span>lib</span>.</span>eachDefaultSystem</span> (</span>system</span>:</span></span>
      let</span></span>
        pkgs</span> =</span> import</span> nixpkgs</span> {</span></span>
          inherit</span> system</span>;</span></span>
        }</span>;</span></span>
</span>
        mkPythonShell</span> =</span> python</span>:</span></span>
          pkgs</span>.</span>mkShell</span> {</span></span>
            name</span> =</span> "</span>python-</span>${</span>python</span>.</span>version</span>}</span>"</span>;</span></span>
            buildInputs</span> =</span> [</span></span>
              pkgs</span>.</span>pyright</span></span>
              pkgs</span>.</span>ruff</span></span>
              pkgs</span>.</span>poetry</span></span>
              (</span>python</span>.</span>withPackages</span> (</span>ps</span>: [</span></span>
                ps</span>.</span>black</span></span>
                ps</span>.</span>flake8</span></span>
              ]))</span></span>
            ]</span>;</span></span>
          }</span>;</span></span>
      in</span></span>
      {</span></span>
        devShells</span> =</span> {</span></span>
          python39</span> =</span> mkPythonshell pkgs</span>.</span>python39</span>;</span></span>
          python310</span> =</span> mkPythonShell pkgs</span>.</span>python310</span>;</span></span>
          python311</span> =</span> mkPythonShell pkgs</span>.</span>python311</span>;</span></span>
          python312</span> =</span> mkPythonShell pkgs</span>.</span>python312</span>;</span></span>
        }</span>;</span></span>
      }</span></span>
    )</span>;</span></span>
}</span></span></code></pre>
I keep one devShell for each version of Python, and only install tools that are required for Python development but are not specified in the project dependencies so they don't litter my $PATH</code> when I'm not using them. I prefer to keep this package set small so that it breaks less often.</p>
To use it, you're gonna have to create a new git repository, dump the code above in a flake.nix</code>, and then run nix flake lock</code>. You can also try running one of the shells with nix develop .#python312</code> to make sure that everything is working correctly.</p>
This flake is freestanding and lives outside of any existing repos, and if you manage to convert some coworkers to Nix it can be pushed to the company's git forge of choice.</p>
The .envrc</h2>
direnv</a> is a wonderful tool and if you're not using it yet, you should check it out. It installs a hook inside your shell that runs when you change directories, and when it detects that an .envrc</code> file is present in the current directory or further up the tree, it runs the commands specified in that .envrc</code> file and updates the env variables accordingly. This means that you can set env variables, add executables to your $PATH</code> and, crucially, set your Python venv automatically.</p>
This .envrc</code> is a simple shell script that is executed with some predefined utility commands (the stdlib</a>). These include loading .env</code> files with dotenv</code> and automatically setting the correct interpreter version and installing dependencies for several languages. We don't need most of that though, because the Nix dev environment manages the Python version for us.</p>
If you're using home-manager</code>, the installation is as easy as:</p>
{</span></span>
  programs</span>.</span>direnv</span> =</span> {</span></span>
    enable</span> = true;</span></span>
    nix-direnv</span>.</span>enable</span> = true;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
nix-direnv</code> is absolutely required when you're working with flakes. Without it, it may take several seconds to cd</code> into the project directory. With nix-direnv</code>, loading previously cached flakes will take less than a second.</p>
To drop into one of the Python shells we created in our flakes, create an .envrc</code> file in the root of a repository containing this:</p>
use</span> flake ../path/to/flake#python310</span></span></code></pre>
(The path/to/flake can be anything that is accepted as a flake URL</a>: a relative path from your current directory, a git repository on github or your employer's git forge, or a URL that points to a tarball.)</p>
Then close the file, run direnv allow</code>, and you should see Nix preparing a dev environment containing the Python 3.11 interpreter and all the tools we specified in the flake. This might take a while the first time you do it, but after the initial setup it'll be instantaneous. Try it out!</p>
$ cd project</span></span>
direnv: loading project/.envrc</span></span>
direnv: using flake ../path/to/flake#python310</span></span>
direnv: nix-direnv: using cached dev shell</span></span>
direnv: export +AR +AS +CONFIG_SHELL ...</span></span>
$ black --version</span></span>
black, 24.4.2 (compiled: yes)</span></span>
Python (CPython) 3.10.13</span></span>
$ python -V</span></span>
Python 3.10.13</span></span>
$ cd ..</span></span>
direnv: unloading</span></span>
$ black --version</span></span>
bash: black: command not found</span></span>
$ python -V</span></span>
Python 3.9.6</span></span></code></pre>
The .envrc</code> file should live at the root of your project, but if you don't want to check it into git or add it into .gitignore</code> you can sneakily add an ignore for it inside your project's .git/info/exclude</code>.</p>
.direnv/</span></span>
.envrc</span></span></code></pre>
Now if you run git status</code>, you won't see any added files!</p>
The venv</h2>
For reasons I won't go into here, we're still using pip</code> and good old requirements.txt</code> files to specify dependencies rather than poetry</code> or any of the fancy new Python tooling. To simplify this dev environment setup and keep it close to our coworkers', we're gonna use normal Python tooling to set up the virtual env and install dependencies.</p>


First of all, create the venv.</p>
python</span> -m venv venv</span></span></code></pre></li>

Then add these lines to your .envrc</code> to make direnv</code> load the venv. (I added the VIRTUAL_ENV_DISABLE_PROMPT</code> bit because it messes up my Starship prompt, but you may want to keep it.)</p>
export</span> VIRTUAL_ENV_DISABLE_PROMPT</span>=</span>1</span></span>
source</span> venv/bin/activate</span></span></code></pre></li>

Enter the venv by allowing the changes you made to your .envrc</code>.</p>
direnv</span> allow</span></span></code></pre></li>

Now that you're inside the venv, upgrade pip</code> and setuptools</code> and install wheel</code>. (Imma keep it real with you: this is just cargo culting. I don't actually know how much of this is needed. Feel free to @ me for this one.)</p>
pip3</span> install --upgrade pip setuptools</span></span>
pip</span> install wheel</span></span></code></pre></li>

Let's get installing!</p>
pip</span> install -r requirements.txt</span></span></code></pre></li>
</ul>
The end</h2>
Repeat this for every Python repository you might have at your company. That's it! You can start working on the actual tasks in your sprint now.</p>


Do I not like Ruby anymore?
steen — Tue, 28 May 2024 00:00:00 +0000
I recently started working at a Python shop. The reasons behind this choice of employment are very much unrelated to the technology stack. Python is not my favorite programming language</a>. In fact, allow me to drop the euphemism and express my pure, unadulterated thoughts about it: I never liked Python, I see it as a huge red flag and I think the world would be a better place if we all decided to finally move on from it.</p>
With that out of the way, let's talk about how I've recently started to come around to Python and actually kind of like it in some aspects?</p>
I (used to) love Ruby</h2>
Ruby was my first love as a programmer. It is a playful, concise, elegant, expressive language that is built out of a handful of simple concepts with a good serving of syntax sugar on top.</p>

There's no distinction between objects and primitives; everything is actually</em> an object, even nil</code></a>!</li>
You can reimplement if</code></a> using blocks and two additional methods on NilClass</code> and FalseClass</code> if you want!</li>
Method calls are just syntax sugar for send</code>ing messages to objects</a>!</li>
You can define new methods on an object at call time using method_missing</code></a>!</li>
</ul>
Ruby was clearly designed</em> taking inspiration from such language designer's languages as Smalltalk and Lisp, and as a budding Schemer with an interest in programming language design, that inspired me a lot.</p>
Now, Python and Ruby were the two most popular "scripting" languages at the time. Ruby exploded thanks to Rails, and Python saw a lot of success as a language for data science and a better choice than Perl for command line tools and scripts.</p>
The two languages were often compared and contrasted, and of course I, as a fan of Ruby, had a lot of opinions about Python.</p>
Python as a worse Ruby (and an even worse Scheme)</h2>
I kind of lied earlier when I said that Ruby was my first love as a programmer. The first time I started to really grok</em> programming was when I learned a little bit of Scheme. I learned recursion before for</code> loops, and I learned immutability before mutability.</p>
As I said in the beginning of this post, I didn't like Python. My dislike for it was best exemplified by its choice to make if</code> a statement</em> rather than an expression. If you want to assign a variable conditionally in Python you have to declare</em> it first, and then mutate</em> it from inside the if</code> statement, and this just didn't sit right with me.</p>
(Yes, you can also use the <then-expression> if <condition> else <else-expression></code> inline conditional, but that looks weird to me even now.)</p>
lambda</code>s, my bread and butter as a Rubyist and Schemer, are replaced by horrible twisted versions of themselves that don't allow statements. Even print</code> was a statement before Python 3.0, so you couldn't use it inside of a lambda</code>. The horror!</p>
In summary, Python to me just felt unpleasant</em> to use. It's a language that prides itself on having only one way to do things, and that way was usually not the one I wanted to use.</p>
Type systems for the untypable</h2>
At some point I found myself writing frontend code. JavaScript is not my favorite language, but TypeScript tried very hard</em> to get me to love it.</p>
I consider TypeScript to be the gold standard when it comes to type systems on top of dynamic languages. It is powerful enough to model almost all Real World JS, and while this approach introduces a lot of complexity, it also brought the language a lot of success.</p>
TypeScript does a bit</em> more work than your classic ML (as in Meta Language</a>) type system. TypeScript can:</p>

Narrow</a> a variable's type based on the return type of a function you call on it!</li>
Manipulate types by destructuring</a> and constructing</a> them!</li>
Make choices</a> while constructing a type based on subtyping rules!</li>
</ul>
The last two features in particular unlock some incredible type-level programming potential. TypeScript is one of the few type systems in which you can play a text adventure</a> and query a database</a>!</p>
On top of being the most complex (and fun) type system of most languages out there, let alone those topping the TIOBE Index, TypeScript certainly makes JavaScript's flaws a lot more bearable. It almost made me enjoy</em> writing frontend code for a living.</p>
I changed</h2>
One thing I learned while writing TypeScript was that bad language features can be excused by some static analysis. Maybe</em> not having match</code> is ok when you have type narrowing based on control flow and unions. Maybe</em> not having if</code> expressions is ok when you can statically check that a variable was initialized after an if</code> statement. Maybe</em> stringly typed</a> variables are ok when you can statically enumerate the magic strings and ensure they are constructed correctly.</p>
I also started writing quite a bit of Rust, which is a great language to show your functional programmer friends when you want to tell them that mutability is actually fine</em>.</p>
Python changed</h2>
Python is not the same language it used to be. Now it supports type hints! And match</code> statements</a> with destructuring! Even print</code> got turned into a normal function!</p>
The type hints are easily my favorite feature. Not only do they provide type information to a good ecosystem of type checkers, but they can also be used by libraries to validate schemas</a> and simplify defining web APIs</a>.</p>
I think they're a great case study for integrating types in an existing ecosystem.</p>

They are built into the language, so unlike TypeScript where you need to insert a separate build step, there is no cost of adoption.</li>
They are orthogonal to type checking and inspectable from within the language, so libraries like Pydantic can leverage them to bring benefits even to users who don't run a type checker. Everybody wins!</li>
The aforementioned libraries can serve as a gateway drug into the magical world of types ✨</li>
</ul>
And here are some features of Python that I like which are unrelated to types:</p>

Keyword arguments. You can call any function using the argument names as keywords without any ceremony in the function definition. I wish every language had this feature!</li>
It has namespaces, which are pretty good.</li>
The lambdas are bad, but comprehensions and generator functions are neat. They remind me of F#'s sequence expressions.</li>
Having preferably only one way to do things is a good feature when you're working with many people on a project.</li>
</ul>
Ruby didn't change</h2>
So where does that leave Ruby, my former favorite language? Well, Ruby didn't change as much in the last 10 years. A bunch of performance work to benefit big applications like Rails, a couple of interesting features that didn't seem to catch on, and a handful of new syntax additions that don't amount to much. Nothing quite as game-changing as type hints. Matz doesn't seem to care for them.</p>
I still use Ruby for some scripts because I know it like the back of my hand, but... it just doesn't feel the same. I get just a bit more irked by its quirks. I miss features from other languages. I long for keyword arguments, type hints, namespaces, I long for... Python!?</p>
Maybe this is a sign that I've changed too much for Ruby. We had a lot of fun together, but it's time to leave it behind. Goodbye Ruby, and thanks for all the chunky bacon.</p>
And to Python I say: good job! You can have one of my midnight chicken nuggets. You deserve it.</p>


Solving Advent of Code 2021 Day 13 with a linear equation
steen — Mon, 13 Dec 2021 00:00:00 +0000
This year I'm doing Advent of Code in Erlang. The data structures it provides are all immutable, so I have to be kinda clever if I don't want my solutions to run too slowly. This is my solution for Day 13: Transparent Origami</a>.</p>
The first thing I noticed when I got the input was that all the folds are right down the middle, so I figured that instead of doing all the folds iteratively you could get the final position of a point on the paper just knowing the X and Y of the point and the X and Y offsets of the last folds.</p>
Imagine that you have a 15x11 piece of paper.</p>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span>
...............</span></span></code></pre>
And that the instructions tell you to:</p>

fold along y=5</li>
fold along x=7</li>
fold along y=2</li>
fold along x=3</li>
</ul>
If you were to fold that piece of paper following the instructions and then unfold it, you'd get a grid of 3x2 rectangles with a line of crease between each of them. Notice that the width and height of the rectangles are the same as the last x and y the paper was folded along.</p>
...|...|...|...</span></span>
...|...|...|...</span></span>
---+---+---+---</span></span>
...|...|...|...</span></span>
...|...|...|...</span></span>
---+---+---+---</span></span>
...|...|...|...</span></span>
...|...|...|...</span></span>
---+---+---+---</span></span>
...|...|...|...</span></span>
...|...|...|...</span></span></code></pre>
The key thing here is understanding how these rectangles will end up looking when the whole piece of paper is folded. The top left rectangle is unchanged, but the next one on the right will be flipped horizontally</em>, and the next one on the right will be unchanged again. The first rectangle down from the top left will be flipped vertically</em>, and the one on its right will end up rotated by 180 degrees</em>, because it'll be flipped both horizontally and vertically.</p>
Here's a visualization, where u = unchanged, h = flipped horizontally, v = flipped vertically and r = flipped both directions.</p>
uuu|hhh|uuu|hhh</span></span>
uuu|hhh|uuu|hhh</span></span>
---+---+---+---</span></span>
vvv|rrr|vvv|rrr</span></span>
vvv|rrr|vvv|rrr</span></span>
---+---+---+---</span></span>
uuu|hhh|uuu|hhh</span></span>
uuu|hhh|uuu|hhh</span></span>
---+---+---+---</span></span>
vvv|rrr|vvv|rrr</span></span>
vvv|rrr|vvv|rrr</span></span></code></pre>
So if you want to get the final X coordinate of a point in the 3rd rectangle right from the top left (the one at 2,0, if the first rectangle is 0,0), for example 10,0, you'd have to subtract the number of creases between that and the first rectangle, in this case 2, and then modulo by the width of the rectangle, which is 3, which gives you 2.</p>
x = 10</span></span>
width = 3</span></span>
creases = 2</span></span>
final_x = (x - creases) % width</span></span></code></pre>
If you want to get the final X coordinate of a point in the 2nd rectangle though, for example 0,4, you'd have to perform the same operations as above and then subtract it from the width of the rectangle minus 1, since the rectangle is flipped horizontally.</p>
final_x = width - ((x - creases) % width) - 1</span></span></code></pre>
What I did at this point was go on Wolfram Alpha to try and figure out a formula for getting the number of creases given a certain X. I'm sure you can find that out somehow. I didn't, but what I noticed was that the function I described above formed a certain shape...</p>
 |</span></span>
 | 2 2     2 2     2</span></span>
 |1   1   1   1   1</span></span>
-0-----0-0-----0-0--</span></span>
 |</span></span></code></pre>
If you plot the input X as the X of the graph and the expected output numbers as the Y, you get this funny looking graph as a result. If you want to know what position a certain number will end up in, just walk the X that many times and find the number at that position.</p>
Some X positions are empty because that's where the creases are. If you put some pointy tips on those positions you'd end up with a proper triangle wave</strong>.</p>
 |</span></span>
 |  ^       ^       ^</span></span>
 | / \     / \     /</span></span>
 |/   \   /   \   /</span></span>
-/-----\-/-----\-/---</span></span>
v|      v       v</span></span>
 |</span></span></code></pre>
So how do we use this knowledge to solve Day 13 of Advent of Code 2021? Well, you could look at the explanation on Wikipedia and translate the general formula into your favourite language, but that implies you can read math notation. Or you could google "triangle wave function programming" and find this StackOverflow answer</a> and then copy and paste that in your code.</p>
y = (A/P) * (P - abs(x % (2*P) - P))</span></span></code></pre>
Since the amplitude and the period of the wave are the same (we always advance by 1) we can get rid of the first division. You'll also notice that the graph of the function for the width of the rectangle goes from -1 to 3 (an interval of 4), so we'll have to add 1 to both the width and the X to use this, and in the end we'll have to subtract 1 from the output to return it to the 0..2 interval we need.</p>
This is what I ended up with:</p>
x += 1</span></span>
width += 1</span></span>
final_x = (width - abs(x % (2 * width) - width)) - 1</span></span></code></pre>
It runs pretty quickly even in Erlang</a>.</p>


Types of parser combinators
steen — Tue, 16 Nov 2021 00:00:00 +0000
I've been trying to write this post for a long while. Parser combinators to me are a Leitmotiv that plays whenever I need to parse something and the times look dire. Every time I almost forget they exist, and every time a light will go off inside my head and I'll think, "I know! I'll use parser combinators!"</p>
Parser combinators are a universally useful concept. They're like parsley, because they go well with any sort of data that you might wanna throw at them. And yes, parser combinators are</em> like burritos</a>.</p>
Let me explain myself.</p>
You have a parsing problem</h2>
As you do, because what programs do is transform data, and you only have one hammer, and so all programs are compilers. Usually this involves consuming less-structured input and producing more-structured output. This is called parsing</a>, and this is why you have a parsing problem.</p>
This input could be a stream</em> of things, be it characters, bytes, or tokens, or it could be a tree</em> of things, be it a hash table, the AST of a program, JSON, HTML, s-expressions, or any sort of arborescent structure you might think of. What a parser does, then, is to take that structure, or maybe just part of it, and make sense of it. Sometimes it doesn't make sense, and in that case we want to return an error. We can turn this into a type:</p>
type</span> Output</span><</span>T</span>></span> =</span> {</span></span>
  value</span>:</span> T</span>;</span></span>
  rest</span>:</span> Input</span> |</span> null</span>;</span></span>
}</span>;</span></span>
</span>
type</span> Parser</span><</span>T</span>></span> =</span> (</span>i</span>:</span> Input</span>)</span> =></span> Result</span><</span>Output</span><</span>T</span>>,</span> Error</span>></span>;</span></span></code></pre>
In other words, a parser is a function that takes some input data and returns either some more-structured data with or without the rest of the input depending on the parser, or an error, if the data doesn't make sense.</p>
Hot parsers in your area</h2>
So what are some things that are parsers? JSON.parse</code></a> is an obvious parser. It fully consumes its input and throws an error if it doesn't make sense, or if there's trailing data.</p>
>> JSON.parse("123")</span></span>
<- 123</span></span>
>> JSON.parse("")</span></span>
<- Uncaught SyntaxError: ...</span></span>
>> JSON.parse("123asd")</span></span>
<- Uncaught SyntaxError: ...</span></span></code></pre>
parseInt</code></a> is another obvious parser, one with confusing semantics and a few footguns. parseInt</code> accepts trailing data and returns NaN</code> when the input doesn't make sense.</p>
>> parseInt("123")</span></span>
<- 123</span></span>
>> parseInt("0x7b")</span></span>
<- 123</span></span>
>> parseInt("123asd")</span></span>
<- 123</span></span>
>> parseInt("asd")</span></span>
<- NaN</span></span></code></pre>
RegExp#exec</code></a> is also a parser. This one can return multiple outputs, and the match also doesn't have to start right at the beginning of the input.</p>
>> const matchB = (str) => str.match(/b/);</span></span>
>> const match = matchB("abc");</span></span>
<- Array ["b"]</span></span>
>> match.index</span></span>
<- 1</span></span></code></pre>
But we can go deeper. Indexing an array can also be called a parser, one that doesn't return the rest of the input and returns undefined</code> on error.</p>
>> const first = (array) => array[0];</span></span>
>> first([1, 2, 3])</span></span>
<- 1</span></span>
>> first([])</span></span>
<- undefined</span></span></code></pre>
By this logic, Array#find</code> could also be used to construct a parser. This one also doesn't return the rest of its input and returns undefined</code> on error.</p>
>> const findEven = (array) =></span></span>
  array.find((n) => n % 2 === 0);</span></span>
>> findEven([1, 2, 3, 4])</span></span>
<- 2</span></span>
>> findEven([1, 3, 5])</span></span>
<- undefined</span></span>
>> findEven([])</span></span>
<- undefined</span></span></code></pre>
But it's not only lists of data that can be parsed. Object indexing is also parsing!</p>
>> const getNestedItem = (o) => o?.a?.b?.c;</span></span>
>> getNestedItem({ a: { b: { c: 1 } } })</span></span>
<- 1</span></span>
>> getNestedItem({})</span></span>
<- undefined</span></span></code></pre>
Other examples could be String#slice</code>, Set#has</code>... The list could go on.</p>
These functions don't exactly match the signature of the Parser</code> we defined above, but they match the spirit</em>. Take something, apply some logic to make sense of it, and return either an output that tells you something about that input, or an error.</p>
Ok, so?</h2>
You've done well to make it this far, but I'm sure you, hypothetical reader #1 who lurks all the colored websites and has already seen countless posts about parser combinators, know all about parser combinators. You know the char</code> parser and you know the string</code> parser and you might even know the regexp</code> parser. You might also know some variation of the token</code> parser and the byte</code> parser and maybe you've even given nom</a> a try.</p>
And I'm sure you, hypothetical reader #2 who has just read the paragraph above and has no idea what I'm talking about, have some questions. To you I recommend reading You could have invented parser combinators</a>, an excellent post that might give you an intuition for understanding parser combinators, and then coming back to this post.</p>
Knowing all that you might be wondering, what's the point of this post? Do we really need yet another</em> parser combinator post? Searching "parser combinators" yields tens, even hundreds of posts, tutorials, books, libraries, and so on. I'm not sure there's as many as there are monad tutorials, but it looks close enough to me.</p>
I would be inclined to agree with you; I've read a few dozen of these posts, and I see them pop up on the colored websites every now and then. I don't even click on them anymore because they mostly say the same things in a slightly different sauce.</p>
However, I would still urge you to read on, firstly because this is my</em> parser combinators blog post and there are many like it but this is mine, and secondly because I don't think I've seen this specific bit of insight in any of the aforementioned blog posts. Ready?</p>
Parser combinators can parse much more than strings and bytes</h2>
You might have noticed that I added object indexing as a form of parsing. This is one of the key components of Elm's Json.Decode</a> module. Rescript also has a similar library</a>. That's right, you can parse JSON with parser combinators, and I don't mean deserializing a string into a JSON tree; I mean turning a JSON tree into typed data that you can actually work with.</p>
This is not much of an issue in TypeScript because JSON.parse</code> returns any</code> and that means it will just trust you that whatever data it just parsed has the shape you told it would. But that's not really parsing, that's an unsafe type cast!</p>
Elm</a> aims to be a language with no runtime exceptions, and it achieves that goal by not trusting anything that comes from the outside world; if you want to query an external API that speaks JSON, you'll have to parse</em> that untrusted JSON data into an Elm record using a Decoder</code>.</p>
This is what a decoder for a simple JSON object with two fields looks like.</p>
type alias User =</span></span>
  {</span> name</span> : String</span></span>
  ,</span> age</span> : Int</span></span>
  }</span></span>
</span>
userDecoder</span> : Decoder Info</span></span>
userDecoder</span> =</span></span>
  map2 User</span></span>
    (</span>field</span> "</span>name</span>"</span> string</span>)</span></span>
    (</span>field</span> "</span>age</span>"</span> int</span>)</span></span></code></pre>
Elm doesn't outright call them that because it's afraid of complex terminology, but map2</code> and field</code> are parser combinators. They're functions that take parsers as arguments and return another parser that combines them in some way. If you take a careful look at the Json.Decode</code> documentation you'll find all the usual suspects: list, dict, field, maybe, oneOf, all the map functions, andThen, etc. are all names you're probably familiar with if you've worked with parser combinators.</p>
So what's the difference between this and most other parser combinator libraries out there? Well, the combinators are mostly the same, but the building blocks are different. JSON contains simple fields like booleans, numbers, and strings, but also ordered collections (arrays) and unordered key-value collections (objects), so the simple char</code> parser won't help much here.</p>
To parse all this nonsense, Json.Decode</code> provides different base parsers. There's one for each of the JSON data types: string</code>, bool</code>, int</code>, float</code>, list</code>, and dict</code>. Then it provides field</code>, which pulls a value out of an object by name, and index</code>, which pulls an item out of an array by index.</p>
The rest of the combinators are mostly the same as in stream-based parser combinators, which leads me to another one of my points.</p>
There can be different types of parsers</h2>
I think the main difference between a parser that consumes streams of items, such as a string, and a parser that consumes an unordered key-value collection, such as a JSON object, comes down to how you answer this question: how do you pull a value out of that collection?</em></p>
The answer varies depending on a few factors:</p>

Is the collection ordered or unordered?</li>
Can the collection be indexed by a key?</li>
Can the keys be enumerated?</li>
Can the keys be sorted?</li>
</ul>
Let's see how some basic data structures fare with these questions:</p>

Streams</strong> are ordered but cannot be indexed, so to pull out a value we can only advance</em> them.</li>
Sets</strong> are unordered and can be indexed, but the keys can't be enumerated, so to pull out a value we can only index</em> them using a key.</li>
Structs</strong> (or objects) are unordered but can be indexed, so we can index</em> them easily, but since the keys can be enumerated and they can be sorted we could also come up with a way to advance</em> them.</li>
Arrays</strong>, strings</strong> and tuples</strong> are ordered, they can be indexed, and keys can be enumerated since they have a fixed length, so we can either advance</em> or index</em> them.</li>
Tagged unions</strong>, or variants, discriminated unions, sum types or whatever you might wanna call them, are similar to streams but they only contain one element, so technically we can advance them, but we can only do it once and there's gonna be several functions we can use to advance, typically one for each case of the union like in Elm's Json.Decode</code>. I'm calling this action consume</em>, but we could also view it as a special case of advance</em>.</li>
</ul>
To sum up, these are the different types of basic parsers we have identified:</p>

Consume</strong>-type parsers operate on the full input. The pull function takes the full input and only returns an output. Some examples are JavaScript's JSON.parse</code>, or the basic parsers in Elm's Json.Decode</code>.</li>
Advance</strong>-type parsers operate on a stream of data. The pull function takes the input and returns both the output and the next input. If the input is fully consumed</em>, the next input is empty. The basic parsers in most parser combinator libaries fall under this category.</li>
Index</strong>-type parsers operate on a collection of data that can be indexed. The pull function takes both the input and an index as arguments, and returns the output. These kinds of parsers can decide whether they want to consume the input and return the next input along with the output, or leave the input untouched. Some examples are indexing an array or an object, or the field</code> parser in Elm's Json.Decode</code>.</li>
</ul>
Depending on the type of parser you're using, some combinators may or may not be applicable. For example, sequencing combinators don't make sense in consume- and index-type parsers. Some basic parsers such as any</code> also cannot be implemented in index-type parsers because the pull function requires an index to be passed to it.</p>
Looking back at Elm's Json.Decode</code> we can see that it uses both consume- and index-type parsers, one for parsing single JSON values and the other for parsing JSON objects, so all of these kinds of parsers can coexist with each other when parsing complex nested data.</p>
Thoughts</h2>
I decided to finally write this post because I've been working on parsing the game files of the iOS version of Kamaitachi no Yoru, one of the first "sound novels", which is a fancy name for a text CYOA game with some graphics and sound and music. The files are just HTML and JS, and I could</em> just slap them into a web browser and do some hacks to get them working (which I sort of did already), but it's much more interesting to parse them into a declarative format and do some fancy analysis on them. I could do some nice stuff like preload the next page's background image and music, and some fancy stuff like adding an in-game flowchart like some of the other ports of Kamaitachi no Yoru did. I was getting a bit bored writing a recursive descent parser for this and then I remembered about parser combinators, so there you have it.</p>
This post is a brain dump of all the stuff I've been thinking about while writing other parser combinators in the past. I wrote one that consumes streaming XML</a> and another one for JSON</a> and I thought they turned out pretty well, but figuring out how to classify and compose them required some more thinking, and this is it.</p>
If you were expecting an implementation of all these things I just wrote about, too bad! Maybe I'll write another post about it when I'm done writing the parser for these game files.</p>
If you were expecting the announcement of a library of sorts, too bad! I don't know if I have it in me to write a generally useful implementation of this. I'll probably just write what I need for parsing those game files and forget about it. I'm not a library-writing kinda person.</p>
I'm sure somebody else already thought of this stuff but I haven't seen much about it on the internet, do tell me if you know of anything else. I've seen that F#'s XParsec</a> already implements some of this stuff but that's about it. Hutton and Meijer (1996)</a> also mentions that "One could go further (as in (Hutton, 1992</a>), for example) and abstract upon the type String of tokens"</em>, I haven't read Hutton 1992 yet but I guess I should.</p>


NixOps is easier than I thought
steen — Thu, 11 Nov 2021 00:00:00 +0000
TL;DR: if you have an underpowered machine or two in your house or a small server that you're already managing using NixOS, and you find that running nixos-rebuild</code> on it takes too long, you can easily keep your current configuration untouched and let a more beefy machine build it. Jump to the end of this post for a sample NixOps specification and instructions on how to use it.</p>
Also, NixOps apparently has some issues</a> involving local state that make it hard to share a deployment with other machines. I just read about a tool called morph</a> that is almost a drop-in replacement for NixOps and doesn't share these issues. Sadly it is 3AM here and this here setup works well enough for me so I really can't be bothered to check it out right now, but maybe at some point I will and maybe you might want to do it upfront. This</a> is a good post about it.</p>

I have a Raspberry Pi 3B+ sitting next to my router. I use it to host a couple things to my local network. Here's a photo.</p>
</p>
That hunk of metal I just got also acts as a heatsink and it brought down the CPU temperature by 10°C. That's pretty good!</p>
You might remember it from a previous post</a>, in which I talked about my experience with NixOS' distributed builds. It's a slow machine and you really don't want to build things directly on it, so at the time I reached for distributed builds to make the experience of rebuilding my configuration a little less painful. That worked out alright, but we can do better.</p>
While distributed builds do</em> make executing a nixos-rebuild</code> much faster, the Nix expression describing the whole system is still evaluated on the Pi itself, which in the best case results in a virtually nonfunctional system for a couple minutes, and in the worst a slow death as swap fills out. I usually pull the plug when that happens because I can't stand watching the poor thing suffer.</p>
But! There is a fourth solution to this issue that I failed to consider on the previous post though: NixOps! The NixOps user manual</a> describes it as:</p>

[...] a tool for deploying NixOS machines in a network or cloud.</p>
</blockquote>
This description initially put me off from using it. It makes it sound like something you'd only use when you have a bunch of servers, and that just using it for managing one machine would be overkill. It also makes it sound like there's a big learning curve, I mean there's a big one page html manual about it and ain't nobody got the time to read all that. Figuring out Nix already took me long enough.</p>
And surely I couldn't just import</code> the configuration I was using for the Pi and expect it to work with NixOps, right? I'd seen a couple posts about NixOps but they usually involved creating a new server with a new configuration that I didn't really care about, so maybe I'd have to make some changes.</p>
...Or would I?</em></p>
This might be a gross oversimplification, but all NixOps does is evaluate a system configuration on your machine, build it, copy the results on one or more target machines and make them switch to that configuration.</p>
In other words, it's like it runs nixos-rebuild</code> using the Pi's /etc/nixos/configuration.nix</code> but on another computer, and all the Pi has to do is download the results of the rebuild and run it. In yet other words, it does exactly</em> what I needed.</p>

I was initially worried that I'd have to make some changes to the Pi's system configuration to deploy it with NixOps, but all I had to do was write a nix expression telling NixOps where to deploy the configuration and some details about the machine architecture, as described in the user manual</a>.</p>
If you're following this at home, make sure to include all</em> your configuration files when you import your existing one, including the hardware-configuration.nix</code> file!</p>
{</span></span>
  network</span>.</span>description</span> =</span> "</span>Raspberry Pi</span>"</span>;</span></span>
  </span></span>
  pi3</span> =</span> {</span> config</span>,</span> pkgs</span>,</span> lib</span>, ...</span> }: {</span></span>
    deployment</span>.</span>targetHost</span> =</span> "</span>192.168.1.x</span>"</span>;</span></span>
    </span></span>
    nixpkgs</span>.</span>localSystem</span> =</span> {</span></span>
      system</span> =</span> "</span>aarch64-linux</span>"</span>;</span></span>
      config</span> =</span> "</span>aarch64-unknown-linux-gnu</span>"</span>;</span></span>
    }</span>;</span></span>
    </span></span>
    imports</span> =</span> [</span></span>
      ./pi-configuration.nix</span></span>
    ]</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
To build an arm64 configuration on an x86_64 system you have to enable arm64 emulation, but I already had that set up from when I was using it for distributed builds, I think I got it from here</a>. In any case, this is all you need to add to your build machine</em>'s configuration.</p>
{</span></span>
  boot</span>.</span>binfmt</span>.</span>emulatedSystems</span> =</span> [ "</span>aarch64-linux</span>" ]</span>;</span></span>
}</span></span></code></pre>
Then you have to allow your build machine to log into the target machine via SSH as root, install the nixops</code> command and it's just a couple of nixops</code> commands to create the deployment and send it to the Pi.</p>
$</span> nixops create ./rpi.nix -d rpi</span></span>
$</span> nixops deploy -d rpi</span></span></code></pre>
These commands will create a new deployment called rpi</code> using the specification file above and deploy it. Not that hard after all!</p>

Summing up, NixOS is really nice and you, hypothetical reader who isn't using it, should try it. All issues with documentation and tooling notwithstanding</a>. Here's a couple things that are tangentially related to this post.</p>

Thanks to @cadey</a> and probably a couple others I forget for posting about Nix stuff on Lobsters a lot, those posts got me to try NixOps out.</li>
This is my NixOS configuration</a> if you really</em> want to look at it. The Gitea server it's hosted on is defined in one of the configurations in there. Very meta. Maybe one day I'll switch it to NixOps.</li>
When I wrote "It's a slow machine", it reminded me of the similar line from Penny Lane by The Beatles and the song started playing in my head and it wouldn't stop. Sadly I couldn't think of a way to work it into the post.</li>
</ul>
Good night.</p>


Hellpoint breach map
steen — Sun, 20 Jun 2021 00:00:00 +0000
I just finished playing 
I did explore the 
</p> 
  </span>               </span>        </span>            </span>         </span>         </span>       </span>        </span>           </span>       </span>   </span>     </span>        </span>     </span>   </span>      </span>        </span>       </span>                             </span>        </span>       </span>     </span>  </span>        </span>        </span>          </span>        </span>   </span>     </span>    </span>  </span>  </span>  </span>      </span>  </span>             </span>      
  Offloading NixOS steen — Sun, 24

Hellpoint, an indie soulslike which was surprisingly really good. It has a very deeply interconnected world which I loved exploring, but some areas are kinda confusing to navigate and I quickly realized I needed a map and the ones that were available online were... less than satisfactory. So I made one with Graphviz.</p> game thoroughly but I didn't manage to get the true ending due to a bug with an involved NPC, so it might be missing some things or not be entirely accurate (for example some of the edges between the areas are actually one-way, but I didn't want to rewrite it into a digraph), but if you wanna know how to get to a specific breach you might find it useful.</p> style="color: #D8DEE9; background-color: #2E3440;">graph "Hellpoint breach map" {</span></span> subgraph cluster_Arcology {</span></span> label = "Arcology";</span></span> // Breaches</span></span> Funicular [shape = diamond];</span></span> "Customs Bridge" [shape = diamond];</span></span> "Celestial Workshop" [shape = diamond];</span></span> "West Square" [shape = diamond];</span></span> "Condo Ruins" [shape = diamond];</span></span> </span></span> // Lifts</span></span> subgraph cluster_lift0 {</span></span> label = "Lift";</span></span> l0f1 -- l0f2;</span></span> l0f2 [label = "Floor 2", shape = none];</span></span> l0f1 [label = "Floor 1", shape = none];</span></span> }</span></span> subgraph cluster_lift1 {</span></span> label = "Lift";</span></span> l1f1 -- l1f2 -- l1f3;</span></span> l1f3 [label = "Floor 3", shape = none];</span></span> l1f2 [label = "Floor 2", shape = none];</span></span> l1f1 [label = "Floor 1", shape = none];</span></span> }</span></span> // Links</span></span> l0f1 -- Funicular -- "Customs Bridge";</span></span> "Customs Bridge" -- l1f2 -- "Celestial Workshop";</span></span> "Cosmic theurgist" -- "Celestial Workshop";</span></span> "Eye codes" -- l1f3;</span></span> "Customs Bridge" -- "West Square";</span></span> "West Square" -- "Condo Ruins";</span></span> }</span></span> </span></span> subgraph "cluster_Alma Mater Atrium" {</span></span> label = "Alma Mater Atrium";</span></span> // Breaches</span></span> "Otsego Mansion" [shape = diamond];</span></span> "Shanty Entrance" [shape = diamond];</span></span> "Western Skybridge" [shape = diamond];</span></span> "Tenements" [shape = diamond];</span></span> "Union Park" [shape = diamond];</span></span> "Athaneum" [shape = diamond];</span></span> "Cabaret Cellar" [shape = diamond];</span></span> // Lifts</span></span> subgraph cluster_lift3 {</span></span> label = "Lift";</span></span> l3f1 -- l3f2 -- l3f3;</span></span> l3f3 [label = "Floor 3", shape = none];</span></span> l3f2 [label = "Floor 2", shape = none];</span></span> l3f1 [label = "Floor 1", shape = none];</span></span> }</span></span> subgraph cluster_lift6 {</span></span> label = "Lift";</span></span> l6f2 -- l6f1;</span></span> l6f2 [label = "Floor 2", shape = none];</span></span> l6f1 [label = "Floor 1", shape = none];</span></span> }</span></span> subgraph cluster_Lift9 {</span></span> label = "Lift";</span></span> l9f1 -- l9f2 -- l9f3;</span></span> l9f3 [label = "Floor 3", shape = none];</span></span> l9f2 [label = "Floor 2", shape = none];</span></span> l9f1 [label = "Floor 1", shape = none];</span></span> }</span></span> // Links</span></span> l3f3 -- "Shanty Entrance" -- "Western Skybridge";</span></span> l3f2 -- "Otsego Mansion";</span></span> l6f2 -- "Tenements";</span></span> l6f1 -- "Union Park";</span></span> l9f2 -- "Otsego Mansion";</span></span> l9f2 -- "Cabaret Cellar";</span></span> "Union Park" -- "Otsego Mansion";</span></span> "Union Park" -- "Athaneum";</span></span> }</span></span> subgraph cluster_lift2 {</span></span> label = "Lift";</span></span> l2f1 -- l2f2;</span></span> l2f2 [label = "Floor 2", shape = none];</span></span> l2f1 [label = "Floor 1", shape = none];</span></span> }</span></span> subgraph "cluster_Arcology Underside" {</span></span> label = "Arcology Underside";</span></span> // Breaches</span></span> "Central Mall" [shape = diamond];</span></span> "SAS" [shape = diamond];</span></span> "Outside Platform" [shape = diamond];</span></span> // Lifts</span></span> subgraph cluster_lift7 {</span></span> label = "Lift";</span></span> l7f1 -- l7f2;</span></span> l7f2 [label = "Floor 2", shape = none];</span></span> l7f1 [label = "Floor 1", shape = none];</span></span> }</span></span> "Central Mall" -- l7f2;</span></span> l7f1 -- "SAS"</span></span> "SAS" -- "Outside Platform";</span></span> }</span></span> subgraph "cluster_Alma Mater" {</span></span> label = "Alma Mater";</span></span> // Breaches</span></span> "Belvedere" [shape = diamond];</span></span> "Offices" [shape = diamond];</span></span> "Lobby" [shape = diamond];</span></span> "Uthos's Agora" [shape = diamond];</span></span> // Lifts</span></span> subgraph cluster_lift4 {</span></span> label = "Lift";</span></span> l4f1 -- l4f2;</span></span> l4f2 [label = "Floor 2", shape = none];</span></span> l4f1 [label = "Floor 1", shape = none];</span></span> }</span></span> subgraph cluster_lift5 {</span></span> label = "Lift";</span></span> l5f1 -- l5f2;</span></span> l5f2 [label = "Floor 2", shape = none];</span></span> l5f1 [label = "Floor 1", shape = none];</span></span> }</span></span> // Links</span></span> l4f1 -- "Belvedere";</span></span> "Offices" -- "Belvedere";</span></span> l4f2 -- "Uthos's Agora";</span></span> l5f2 -- "Offices";</span></span> l5f1 -- "Lobby";</span></span> }</span></span> </span></span> subgraph "cluster_Sohn District" {</span></span> label = "Sohn District";</span></span> </span></span> // Breaches</span></span> "Corpse Pit" [shape = diamond];</span></span> "Balcony" [shape = diamond]</span></span> "Control Center" [shape = diamond];</span></span> </span></span> // Links</span></span> "Corpse Pit" -- "Control Center";</span></span> "Corpse Pit" -- "Balcony" -- "Control Center"</span></span> }</span></span> </span></span> subgraph "cluster_Port Issoudun" {</span></span> label = "Port Issoudun";</span></span> </span></span> // Breaches</span></span> "Docking Bay" [shape = diamond];</span></span> "Silos" [shape = diamond];</span></span> "Ozy's Pit" [shape = diamond];</span></span> // Links</span></span> "Docking Bay" -- "Silos";</span></span> "Silos" -- "Ozy's Pit";</span></span> }</span></span> </span></span> subgraph cluster_Observatory {</span></span> label = "Observatory";</span></span> // Braches</span></span> "Podium" [shape = diamond];</span></span> }</span></span> </span></span> subgraph cluster_Embassy {</span></span> label = "Embassy";</span></span> // Breaches</span></span> "Great Halls" [shape = diamond];</span></span> "Pond" [shape = diamond];</span></span> "Admission" [shape = diamond];</span></span> j0 [shape = point];</span></span> // Links</span></span> "Great Halls" -- j0 -- "Pond";</span></span> "Great Halls" -- "Admission";</span></span> }</span></span> </span></span> subgraph "cluster_Arisen Dominion" {</span></span> label = "Arisen Dominion";</span></span> // Breaches</span></span> "Solar Promenade" [shape = diamond];</span></span> "Hall of Remembrance" [shape = diamond];</span></span> "Grand Gallery" [shape = diamond];</span></span> "Tram Station" [shape = diamond];</span></span> "Mine Mausoleum" [shape = diamond];</span></span> "Undisturbed Defas Nemundis" [shape = diamond];</span></span> // Lifts</span></span> subgraph cluster_lift8 {</span></span> label = "Lift";</span></span> l8f1 -- l8f2 -- l8f3 -- l8f4;</span></span> l8f4 [label = "Ministry Audience Chamber", shape = none];</span></span> l8f3 [label = "Grand Gallery", shape = none];</span></span> l8f2 [label = "Promenade", shape = none];</span></span> l8f1 [label = "Mausoleum", shape = none];</span></span> }</span></span> // Links</span></span> "Solar Promenade" -- "Hall of Remembrance" -- "Grand Gallery";</span></span> "Tram Station" -- "Grand Gallery";</span></span> "Grand Gallery" -- l8f3;</span></span> "Mine Mausoleum" -- l8f1;</span></span> l8f4 -- "Undisturbed Defas Nemundis";</span></span> }</span></span> subgraph "cluster_Ikari Walkways" {</span></span> label = "Ikari Walkways";</span></span> // Breaches</span></span> "East Square" [shape = diamond];</span></span> "Crashed Tram" [shape = diamond];</span></span> "Underail" [shape = diamond];</span></span> // Links</span></span> "East Square" -- "Crashed Tram" -- "Underail";</span></span> }</span></span> j0 -- "Solar Promenade";</span></span> "Customs Bridge" -- "East Square";</span></span> "Tenements" -- "Tram Station";</span></span> l2f1 -- "Central Mall";</span></span> l2f2 -- "Otsego Mansion";</span></span> l3f1 -- "Central Mall";</span></span> </span></span> "Otsego Mansion" -- "Celestial Workshop";</span></span> "Western Skybridge" -- l4f1;</span></span> "Offices" -- "Tenements";</span></span> "Lobby" -- "Otsego Mansion";</span></span> </span></span> "Podium" -- "Great Halls";</span></span> "Podium" -- "Docking Bay";</span></span> "Podium" -- l0f2;</span></span> "Podium" -- "Outside Platform";</span></span> </span></span> "Control Center" -- "Docking Bay";</span></span> </span></span> "Control Center" -- l1f1;</span></span> "Condo Ruins" -- "Corpse Pit";</span></span> "Underail" -- "Central Mall";</span></span> "Underail" -- l9f2;</span></span> "Underail" -- "Cabaret Cellar";</span></span> "Ozy's Pit" -- "Pond";</span></span> }</span></span></code></pre> builds to a faster machine
 Jan 2021 00:00:00 +0000
I have a Raspberry Pi 3 sitting next to my router, from which I host a couple things to my local network. I installed NixOS on it and I love the experience: it completely removes the absolute nightmare that is configuring a Linux machine, and I find that incredibly liberating.</p>
But there's a catch: the Pi is slow and it doesn't have a lot of memory. Just evaluating the configuration with nixos-rebuild</code> takes about a minute even when there haven't been any changes, and compiling anything substantial is usually a recipe for Death By Swap.</p>
The other day I tried updating the main channel</a> (the package repository) and upgrading my packages with nixos-rebuild switch --upgrade</code> and found out that one of the packages I was using wasn't available on the main binary cache</a> at cache.nixos.org</code> anymore, so it had to be built locally. The program in question is written in Rust and has a pretty sizeable dependency graph. I left it to build overnight. The morning after it was still stuck on building one of the sub-packages, and I couldn't even open a new ssh connection to the Pi.</p>
There's a couple solutions to this:</p>

Build the program on another machine and add a new package that just fetches this binary and patches it</li>
Setting up a binary cache on another machine</li>
Setting up distributed builds</li>
</ul>
The first one is an ugly hack (in Nix terms, at least) and would probably end up being more trouble than it's worth.</p>
The second option, setting up another binary cache, is definitely better.  The wiki page</a> does a good job of explaining how to set up the server, and on the client you just need to add a couple lines to your configuration.nix</code> to enable it:</p>
{</span></span>
  nix</span> =</span> {</span></span>
    binaryCaches</span> =</span> [ "</span>http://<server url></span>" ]</span>;</span></span>
    binaryCachePublicKeys</span> =</span> [ "</span><the cache's public key></span>" ]</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
The downside is that you have to know beforehand which packages you need to build, and not being very well-versed in Nix I couldn't figure out how to build the specific versions I needed.</p>
So we're left with the third option, distributed builds. The wiki page</a> opens with this paragraph:</p>

Sometimes you want to use a faster machine for building a nix derivation you want to use on a slower one. If you have ssh access to a machine where Nix (not necessarily NixOS) is installed, then you can offload building to this machine.</p>
</blockquote>
Which seems to be exactly what I'm looking for.</p>
The wiki mentions a couple options to add in configuration.nix</code> to enable offloading builds to the client. I used these on the Pi:</p>
{</span></span>
  nix</span> =</span> {</span></span>
    distributedBuilds</span> = true;</span></span>
    buildMachines</span> =</span> [</span></span>
      {</span></span>
        hostName</span> =</span> "</span>builder</span>"</span>;</span></span>
        systems</span> =</span> [ "</span>x86_64-linux</span>" "</span>aarch64-linux</span>" ]</span>;</span></span>
        maxJobs</span> =</span> 4</span>;</span></span>
        speedFactor</span> =</span> 2</span>;</span></span>
        supportedFeatures</span> =</span> [ "</span>nixos-test</span>" "</span>benchmark</span>" "</span>big-parallel</span>" "</span>kvm</span>" ]</span>;</span></span>
      }</span></span>
    ]</span>;</span></span>
  }</span>;</span></span>
  programs</span>.</span>ssh</span>.</span>extraConfig</span> =</span> ''</span></span>
    Host builder</span></span>
      HostName <url of the host></span></span>
      Port 2222</span></span>
      User builder</span></span>
      IdentitiesOnly yes</span></span>
      IdentityFile /root/.ssh/id_builder</span></span>
  ''</span>;</span></span>
}</span></span></code></pre>
I created the key in /root/.ssh/id_builder</code> using the options recommended in this Stack Exchange answer</a> (not that it matters since it's all on my local network):</p>
$</span> ssh-keygen -t ed25519 -a</span> 100</span> -f /root/.ssh/id_builder</span></span></code></pre>
For the host machine I had to go with emulation, since I don't have another ARM64 machine lying around. My beefy desktop runs Windows so I created a VirtualBox machine with 4 cores, 8GB of memory, and a couple GB of hard drive space to store the build results. Setting up emulation was incredibly easy after finding the NixOS on ARM wiki page</a>, all it takes is one line in the VM's configuration.nix</code>:</p>
{</span></span>
  boot</span>.</span>binfmt</span>.</span>emulatedSystems</span> =</span> [ "</span>aarch64-linux</span>" ]</span>;</span></span>
}</span></span></code></pre>
Then I had to activate OpenSSH with services.openssh.enable = true;</code>, add the Pi's public key to /home/builder/.ssh/authorized_keys</code>, forward the SSH port on the VM to 2222, and open that port in the Windows firewall.</p>
To test that it's working you can try building a package on the client with the max-jobs</code> option set to 0.</p>
$</span> nix-build -j0 --expr</span> '</span>with import <nixpkgs> {}; callPackage ./default.nix {}</span>'</span></span></code></pre>
I'm really surprised by how simple all of that was. Setting up a VM that automatically builds packages for another machine while emulating another architecture sounds like a nightmare, but with NixOS it's a couple lines of configuration.</p>
And in case you're wondering, yes, it worked beautifully, and even though the emulation slows things down quite a bit it's still much faster than building things directly on the Pi.</p>


require_so: DRYer StackOverflow copying
steen — Wed, 20 May 2020 00:00:00 +0000
Today I was reading a post on the StackOverflow blog</a>
when I was struck by this passage:</p>

Copying code from Stack Overflow is a form of code cloning</p>
</blockquote>
Code cloning</strong>, you say? In my</strong> DRY Ruby codebase? Not if I</em> can help it!</p>
And so I got to work. After extensive research, I concluded that deleting the snippet from StackOverflow
to make my version the canonical one was not a viable option.</p>
</p>
So I flipped the problem on its head: why not make the StackOverflow version the canonical one?
And thus, require_so</a> was born.</p>
How do I use it?</h2>
Locate the code snippet</p>
</p>
Copy the short permalink below the StackOverflow answer</p>
</p>
Paste it into your code</p>
require</span> "</span>require_so</span>"</span></span>
require_so </span>"</span>https://stackoverflow.com/a/61879644</span>"</span></span></code></pre>
And voilà, the methods defined in the snippet will be brought into scope.</p>
fast_next_smaller</span>(</span>907</span>)</span> #=> 790</span></span></code></pre>
No more code cloning!</p>


Announcing SatouinDp
steen — Tue, 05 May 2020 00:00:00 +0000
My desktop is connected to two monitors and one TV, and for various reasons I find myself needing to switch my primary display more often than most people.</p>
</p>
This is my monitor setup. There's also a TV behind me, which I use to watch movies and play videogames. My laptop is also connected to the central monitor.</p>
When I'm working on my laptop I usually have my central monitor rotated by 90° (code looks better on a tall screen) and a music player open on the right monitor, so either I bend my neck 90° every time I need to do something on the central monitor, or I switch the primary display to the right. If I want to play videogames on the TV I need to switch the primary display to the TV, because most games don't have an option to change the display they go full screen on.</p>
To change primary displays on Windows you have to go on a certain control panel section whose name I can never reliably recall when I'm searching for it from the start menu. (Doesn't help that they change the names of the control panel sections every other update.) Then you have to click on the display you want to make primary, scroll down, and click on a checkbox. That's usually enough to put me off playing any videogames on the TV.</p>
I needed something to do this more quickly.</p>
There's probably a bunch of tools that already do this, but I don't think any of them are open source. If this was Linux I could easily write a script with xrandr, but this is Windows. Stuff here goes clickety click instead of clickety clack, and opening a terminal breaks the harmony.</p>
The other day I finally decided to scratch this itch. A couple hours later I emerged with SatouinDp</a>.</p>
</p>
It's simply a taskbar icon that shows the list of displays, and when you click on one it sets that one as the primary display. It's written in F# and it calls directly to the Win32 API to change the display settings. Maybe I'll write a post about how to do that too some other day.</p>
It's been very useful so far.</p>
Further reading</h1>

Situated software</a></li>
Use Windows API from C# to set primary monitor</a></li>
</ul>


The journey of packaging a .NET app on Nix
steen — Wed, 01 Apr 2020 00:00:00 +0000
Me and a few friends have a Discord server where we all gather once a week (or even twice lately, due to recent events) to watch a movie together. It's been going on for about three and a half years and we thought it'd be about time to make a bot that handles voting and backlog and times for us, so we started writing one, in F#.</p>
My Raspberry Pi running NixOS is on 24/7, so I thought I could run the bot from there and learn something about packaging on Nix while doing so.</p>
Disclaimer</strong>: I have very little experience with packaging in Nix. If you spot any mistakes please tell me and I'll correct them!</p>

First I thought I could cross-compile the bot and then just run the compiled version, so I wouldn't have to bother with packaging the dependencies. Cross-compiling a .NET Core program using the dotnet</code> cli is very easy, you just have to specify the runtime identifier</a> and use the --self-contained</code> flag so the target machine doesn't need to have the .NET runtime installed to run it.</p>
$</span> dotnet publish --self-contained -r linux-arm64 -c Release</span></span></code></pre>
I sent the output to the pi and inspected it with ldd</code>. Running binaries on NixOS is not as easy</a> as on other Linux distros, because the paths to the dynamically loaded libraries are not predictable, so those hardcoded in the source are usually wrong.</p>
I tried to patch the binary with patchelf</code> but didn't have much luck; even when I did manage to make it run it just printed this message:</p>
No usable version of libssl was found</span></span></code></pre>
And then dumped core. Later I learned that I could probably have avoided almost everything below this point, but at the moment I didn't so I decided to just do it the hard way.</p>
The first derivation</h2>
I cloned the repository on the Pi and quickly discovered that the dotnet-sdk</code> package did not support arm64. This was easy enough to fix; I downloaded the .nix file and modified the URL and the hash to point to the linux-arm64</code> version of the SDK. (I promise I'll upstream support for arm64 eventually, but for the moment it's just on my machine.)</p>
It worked well enough; I could build the bot. So I tried to make a simple derivation for it.</p>
{</span> stdenv</span>,</span> libunwind</span>,</span> openssl</span>,</span> icu</span></span>
,</span> libuuid</span>,</span> zlib</span>,</span> curl</span>,</span> callPackage</span></span>
,</span> dotnet-sdk</span> }:</span></span>
let</span></span>
  rpath</span> =</span> stdenv</span>.</span>lib</span>.</span>makeLibraryPath</span> [</span></span>
    stdenv</span>.</span>cc</span>.</span>cc libunwind libuuid icu</span></span>
    openssl zlib curl</span></span>
  ]</span>;</span></span>
  </span></span>
  dynamicLinker</span> =</span> stdenv</span>.</span>cc</span>.</span>bintools</span>.</span>dynamicLinker</span>;</span></span>
in</span> stdenv</span>.</span>mkDerivation</span> rec</span> {</span></span>
  pname</span> =</span> "</span>kino-bot</span>"</span>;</span></span>
  version</span> =</span> "</span>2020-03-29</span>"</span>;</span></span>
  </span></span>
  src</span> = builtins.</span>fetchGit</span> {</span></span>
    name</span> =</span> "</span>${</span>pname</span>}</span>-</span>${</span>version</span>}</span>-git</span>"</span>;</span></span>
    url</span> =</span> https://github.com/steinuil/KinoBot</span>;</span></span>
    ref</span> =</span> "</span>master</span>"</span>;</span></span>
    rev</span> =</span> "</span>275ae0447ab1ab21cba76bb673f00559ed5d9251</span>"</span>;</span></span>
  }</span>;</span></span>
  </span></span>
  buildInputs</span> =</span> [</span> dotnet-sdk</span> ]</span>;</span></span>
  </span></span>
  buildPhase</span> =</span> ''</span></span>
    export DOTNET_CLI_TELEMETRY_OPTOUT=1</span></span>
    export HOME="$(mktemp -d)"</span></span>
    dotnet publish --nologo \</span></span>
      -r linux-arm64 --self-contained \</span></span>
      -c Release -o out</span></span>
  ''</span>;</span></span>
  </span></span>
  installPhase</span> =</span> ''</span></span>
    runHook preInstall</span></span>
    mkdir -p $out/bin</span></span>
    cp -r ./out/* $out</span></span>
    ln -s $out/KinoBot $out/bin/KinoBot</span></span>
    runHook postInstall</span></span>
  ''</span>;</span></span>
  </span></span>
  dontPatchELF</span> = true;</span></span>
  postFixup</span> =</span> ''</span></span>
    patchelf --set-interpreter "</span>${</span>dynamicLinker</span>}</span>" \</span></span>
      --set-rpath '$ORIGIN:</span>${</span>rpath</span>}</span>' $out/KinoBot</span></span>
    find $out -type f -name "*.so" -exec \</span></span>
      patchelf --set-rpath '$ORIGIN:</span>${</span>rpath</span>}</span>' {} ';'    </span></span>
  ''</span>;</span></span>
  </span></span>
  meta</span> = with</span> stdenv</span>.</span>lib;</span> {</span></span>
    homepage</span> =</span> https://github.com/steinuil/KinoBot</span>;</span></span>
    platforms</span> =</span> [ "</span>aarch64-linux</span>" ]</span>;</span></span>
    license</span> =</span> licenses</span>.</span>isc</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
(I took inspiration from this gist</a> and a few other derivations I found to come up with this.)</p>
So I tried to run it:</p>
$ nix repl '<nixpkgs>'</span></span>
Welcome to Nix version 2.3.3. Type :? for help.</span></span>
</span>
Loading '<nixpkgs>'...</span></span>
Added 10863 variables.</span></span>
</span>
nix-repl> kino-bot = callPackage (import ./kino-bot.nix) {}</span></span>
</span>
nix-repl> :b kino-bot</span></span></code></pre>
But it got stuck on the dotnet restore</code> step of the build. I discovered that external connections are not allowed during the build step of a Nix derivation, so I had to fetch the dependencies through Nix</em>.</p>
Packaging the dependencies and a digression on base32 hashes</h2>
It turns out the dotnet</code> command takes a --source</code> argument which lets you specify a folder containing the NuGet packages.  I started by copying the aforementioned gist</a>, which got the list of all direct and transitive dependencies from the obj/project.assets.json</code> file. I didn't want to install Node though, so I rewrote the script in F#.</p>
There's a problem with the script though: the dependencies file specifies a base64-encoded sha512 hash which doesn't correspond to the hash of the zip file, and probably not to the Nix serialization of the path</a> either.</p>
The hashes that Nix uses are also not at all like the ones you see in the wild; they use too many characters for hex, but also too few for base64. In fact Nix uses its own version of base32, more compact than base16 but still only containing ASCII digits and lowercase letters (except e o u t, which were chosen to reduce the chance of the hash containing swearwords</a>). The implementation is specified in src/libutil/hash.cc</a> and it's very compact and easily ported to other languages. This is my F# implementation:</p>
module</span> Base32</span></span>
</span>
let</span> chars</span> =</span> "</span>0123456789abcdfghijklmnpqrsvwxyz</span>"</span></span>
</span>
let</span> length size </span>=</span></span>
    (</span>size </span>*</span> 8</span> -</span> 1</span>) /</span> 5</span> +</span> 1</span></span>
</span>
let</span> fromBytes</span> (</span>bytes </span>:</span> byte</span>[]) =</span></span>
    seq {</span></span>
        for</span> n </span>=</span> length bytes.Length </span>-</span> 1</span> downto</span> 0</span> do</span></span>
            let</span> b</span> =</span> n </span>*</span> 5</span></span>
            let</span> i</span> =</span> b </span>/</span> 8</span></span>
            let</span> j</span> =</span> b </span>%</span> 8</span></span>
            yield</span> int bytes</span>.[</span>i</span>] >>></span> j </span>||| if</span> i </span>>=</span> bytes.Length </span>-</span> 1</span> then</span> 0</span> else</span> int bytes</span>.[</span>i </span>+</span> 1</span>] <<< (</span>8</span> -</span> j</span>)</span></span>
    }</span></span>
    |></span> Seq.map </span>(fun</span> c </span>-></span> chars</span>.[</span>c </span>&&&</span> 0x1f</span>])</span></span>
    |></span> Seq.toArray</span></span>
    |></span> System.String</span></span></code></pre>
You don't really have to use base32, as Nix also supports base16-encoded hashes, but I thought it'd be fun to try implementing it on my own.</p>
But let's go back to the dependencies. After some head scratching because nix-hash</code> apparently returned a different hash for a dependency downloaded through curl than for one downloaded through nix-prefetch-url</code> I figured I just had to pass the -L</code> flag to curl to follow the redirect, and then the hashes were identical.</p>
$</span> nix-prefetch-url https://www.nuget.org/api/v2/package/Argu/6.0.0</span></span>
[</span>0.2</span> MiB DL</span>]</span></span>
path</span> is</span> '</span>/nix/store/rn0qb89ibmn3xv7ay28309r0wj3xaf5q-6.0.0</span>'</span></span>
1zybqx0ka89s2cxp7y2bc9bfiy9mm3jn8l3593f58z6nshwh3f2j</span></span>
</span>
# WRONG</span></span>
$</span> curl -o Argu.6.0.0.zip https://www.nuget.org/api/v2/package/Argu/6.0.0</span></span>
$</span> nix-hash --type sha256 --flat --base32 ./Argu.6.0.0.zip</span></span>
04w8jx2wzss3y2c9bx6dm6lxib03v2jnr89iakcgk93zippfxb0w</span></span>
</span>
$</span> curl -L -o Argu.6.0.0.zip https://www.nuget.org/api/v2/package/Argu/6.0.0</span></span>
$</span> nix-hash --type sha256 --flat --base32 ./Argu.6.0.0.zip</span></span>
1zybqx0ka89s2cxp7y2bc9bfiy9mm3jn8l3593f58z6nshwh3f2j</span></span></code></pre>
And there I was with my newly created discourse.nixos.org</a> account ready to send a post demanding explanations. Oh well!</p>
I had to also write my own version of fetchNuGet</code> because the default one tried to build the artifacts again for some reason, didn't support sha512, and used mono which I'm not using. I used the same gist as above for inspiration.</p>
{</span> baseName</span>,</span> version</span>,</span> sha512</span> }:</span></span>
  let</span> nupkgName</span> =</span> lib</span>.</span>strings</span>.</span>toLower</span> "</span>${</span>baseName</span>}</span>.</span>${</span>version</span>}</span>.nupkg</span>"</span>; in</span></span>
  stdenvNoCC</span>.</span>mkDerivation</span> {</span></span>
    name</span> =</span> "</span>${</span>baseName</span>}</span>-</span>${</span>version</span>}</span>"</span>;</span></span>
    </span></span>
    src</span> =</span> fetchurl</span> {</span></span>
      inherit</span> sha512</span>;</span></span>
      url</span> =</span> "</span>https://www.nuget.org/api/v2/package/</span>${</span>baseName</span>}</span>/</span>${</span>version</span>}</span>"</span>;</span></span>
      name</span> =</span> "</span>${</span>baseName</span>}</span>.</span>${</span>version</span>}</span>.zip</span>"</span>;</span></span>
    }</span>;</span></span>
    </span></span>
    sourceRoot</span> =</span> "</span>.</span>"</span>;</span></span>
    </span></span>
    buildInputs</span> =</span> [</span> unzip</span> ]</span>;</span></span>
    </span></span>
    dontStrip</span> = true;</span></span>
    </span></span>
    installPhase</span> =</span> ''</span></span>
      mkdir -p $out</span></span>
      chmod +r *.nuspec</span></span>
      cp *.nuspec $out</span></span>
      cp $src $out/</span>${</span>nupkgName</span>}</span></span>
    ''</span>;</span></span>
  }</span></span></code></pre>
The nuget2nix</code> script generates a file that looks roughly like this:</p>
name</span>:</span> rec</span> {</span></span>
  cache</span> =</span> linkFarm</span> "</span>${</span>name</span>}</span>-nuget-pkgs</span>"</span> packages</span>;</span></span>
  packages</span> =</span> [</span></span>
    {</span> name</span> =</span> "</span>Argu</span>"</span>;</span></span>
      path</span> =</span> fetchNuGet</span> {</span></span>
       baseName</span> =</span> "</span>Argu</span>"</span>;</span></span>
       version</span> =</span> "</span>6.0.0</span>"</span>;</span></span>
       sha512</span> =</span> "</span>1kiqh4zpasydq5vx4wn5mal5v8c2bdalczja5za9phvq8n9c3s453lj5kmrqar1rfp3504kakb5csxflj7dwy2aas04d0jjw9dhm9g2</span>"</span>;</span></span>
      }</span>;</span></span>
    }</span></span>
    # ...</span></span>
  ]</span>;</span></span>
}</span></span></code></pre>
The linkFarm</code> function, which is only documented in a comment in the source</a> (Nix has a recurring problem with documentation, yes) takes every derivation in its second arguments and links it as a subdirectory into a derivation named after the first, which is exactly what I needed for the --source</code> directory in the restore step of the build.</p>
Before going back to the main file, a few protips about the packages, because these things got me stuck for a while:</p>

If you source the packages from your lockfile</a> you will have to set the RuntimeIdentifiers</code> property in your .[cf]sproj</code>, or else you'll be missing some platform-specific ones like runtime.native.System.Security.Cryptography.OpenSsl</code>.</li>
Make sure you don't download the same dependency twice, or you'll get an error in the ln</code> phase of the linkFarm</code> derivation saying "Permission denied".</li>
There's a few dependencies listed under project.frameworks.<yourTargetFramework>.downloadDependencies</code> in the obj/project.assets.json</code> file that you'll also have to include in the build. These are the ones called like Microsoft.NETCore.App.Runtime.linux-arm64</code> and so on.</li>
</ul>
Finally running the bot</h2>
Nothing much has changed in the main derivation. I just added the link farm derivation to the list of dependencies and set it as source in the dotnet publish</code> command.</p>
let</span></span>
  rpath</span> =</span> "</span>...</span>"</span>;</span></span>
  nugetPkgs</span> =</span> callPackage</span> (</span>import</span> ./kino-bot-nuget.nix</span>) {} "</span>kino-bot</span>"</span>;</span></span>
in</span> stdenv</span>.</span>mkDerivation</span> rec</span> {</span></span>
  # ...</span></span>
</span>
  buildInputs</span> =</span> [</span> dotnet-sdk nugetPkgs</span>.</span>cache</span> ]</span>;</span></span>
</span>
  buildPhase</span> =</span> ''</span></span>
    export DOTNET_CLI_TELEMETRY_OPTOUT=1</span></span>
    export HOME="$(mktemp -d)"</span></span>
    dotnet publish --nologo \</span></span>
      -r linux-arm64 --self-contained \</span></span>
      --source #{nugetPkgs.cache} -c Release -o out</span></span>
  ''</span>;</span></span>
</span>
  # ...</span></span>
}</span></span></code></pre>
After all this I could finally build the package locally, but when I tried to run it I got the same libssl error as in the beginning. Was this all for naught? (Maybe it was.)</p>
Turns out .NET Core only supports version 1.0 of openssl</a>, and the version packaged by Nix is 1.1. This is easily fixed by importing openssl_1_0_2</code> instead of openssl</code>.</p>
   rpath = stdenv.lib.makeLibraryPath [</span></span>
     stdenv.cc.cc libunwind libuuid icu</span></span>
+</span>    openssl_1_0_2 zlib curl</span></span>
-</span>    openssl zlib curl</span></span>
   ];</span></span></code></pre>Adding the package to your system</h2>
Now that I got it running I had to add it to the system, and to do this you need overlays</a>. An overlay is just a function that takes two arguments, named self and super, and returns a set of packages. This is what mine looks like:</p>
self</span>:</span> super</span>: {</span></span>
  dotnet-sdk</span> =</span> super</span>.</span>callPackage</span> ./pkgs/dotnet-sdk.nix</span> {}</span>;</span></span>
  kino-bot</span> =</span> super</span>.</span>callPackage</span> ./pkgs/kino-bot.nix</span> {}</span>;</span></span>
}</span></span></code></pre>
Then I imported it to the main configuration.nix</code> file. (Note the parenthesis around the import: Nix will throw a cryptic infinite recursion error</a> with no stack trace if you forget them!)</p>
{</span></span>
  nixpkgs</span>.</span>overlays</span> =</span> [ (</span>import</span> ./my-overlay.nix</span>) ]</span>;</span></span>
</span>
  environment</span>.</span>systemPackages</span> = with</span> pkgs;</span> [</span></span>
    # ...</span></span>
    kino-bot</span></span>
  ]</span>;</span></span>
}</span></span></code></pre>
I also added a systemd service to start it automatically.</p>
{</span></span>
  systemd</span>.</span>services</span>.</span>kino-bot</span> =</span> {</span></span>
    enable</span> = true;</span></span>
    after</span> =</span> [ "</span>network.target</span>" ]</span>;</span></span>
    wantedBy</span> =</span> [ "</span>multi-user.target</span>" ]</span>;</span></span>
    serviceConfig</span> =</span> {</span></span>
      Restart</span> =</span> "</span>on-failure</span>"</span>;</span></span>
      ExecStart</span> =</span> "</span>${</span>pkgs</span>.</span>kino-bot</span>}</span>/bin/KinoBot --token </span>${</span>secrets</span>.</span>kinoBotToken</span>}</span>"</span>;</span></span>
    }</span>;</span></span>
  }</span>;</span></span>
}</span></span></code></pre>

This took me a few days to get working, and I had to rebuild everything dozens of times to get it working. I omitted several dumb mistakes I made and only kept in those that I had the most trouble with because I thought they could help others.</p>
Nonetheless, I really like NixOS and I'll definitely be using it more and package more things in the future. It's already my main Linux OS on my (personal) laptop and my Raspberry Pi (I use Windows on my desktop and work laptop, sadly) and this was a good occasion to learn more about how its packages work. I'll probably be migrating my server to it too in the future.</p>
Code for this post here</a>. Note: there's many hacks specific to my use-case left in the code and it's probably not usable as-is.</em></p>
Further reading</h2>

Nix pills</a></li>
Nixpkgs manual</a></li>
</ul>


Thoughts on Suspense for data fetching
steen — Wed, 30 Oct 2019 00:00:00 +0000
React's Concurrent Mode</a> has finally
landed in React's experimental builds, and it just so happens that I have to start writing this
new app at work to be used internally, so what better way to get my hands dirty with this new
shiny stuff!</p>
In another post</a> I expressed some disconcert at what little
I remembered of Suspense's API (kinda missed that .read() thingy in the fetch request), and that...
is still there after seeing the full API. I think you'll see what I mean.</p>
Exceptions for control flow</h2>
I happen to have here a sort of minimal working example of "Suspense for data fetching".</p>
const</span> Hello</span> =</span> ({</span> resource</span> })</span> =></span> (</span></span>
  <span></span>Hello </span>{</span>resource</span>()</span>}</span></span></span>
)</span>;</span></span>
</span>
const</span> SuspendTest</span> =</span> ()</span> =></span> {</span></span>
  const</span> resource</span> =</span> suspendPromise</span>(</span>async</span> ()</span> =></span> {</span></span>
    await</span> sleep</span>(</span>3000</span>)</span>;</span></span>
    return</span> "</span>from inside a shell</span>"</span>;</span></span>
  }</span>)</span>;</span></span>
</span>
  return</span> (</span></span>
    <</span>Suspense fallback</span>=</span>"</span>loading...</span>"</span>></span></span>
      <</span>Hello resource</span>={</span>resource</span>} /></span></span>
    </</span>Suspense</span>></span></span>
  )</span>;</span></span>
}</span>;</span></span></code></pre>

This will display "loading..." for 3 seconds and then show "Hello from inside a shell"</li>
sleep</code> is (ms) => new Promise((resolve) => setTimeout(resolve, ms))</code></li>
We'll call "resource" the thing that provides our Hello</code> component with the data it needs to render</li>
</ul>
The resource is clearly a promise but you don't have to await it; you just call it as if you already
had the data inside it. How the hell does this work? The title of this section kinda spoiled it,
but here it is anyway:</p>
export function</span> suspendPromise</span><</span>T</span>>(</span>thunk</span>:</span> ()</span> =></span> Promise</span><</span>T</span>>) {</span></span>
  let</span> state</span> =</span> {</span> status</span>: "</span>PENDING</span>" }</span>;</span></span>
</span>
  const</span> pendingPromise</span> =</span> (</span>async</span> ()</span> =></span> {</span></span>
    try</span> {</span></span>
      state</span> =</span> {</span> status</span>: "</span>SUCCESS</span>",</span> data</span>:</span> await</span> thunk</span>()</span> }</span>;</span></span>
    }</span> catch</span> (e)</span> {</span></span>
      state</span> =</span> {</span> status</span>: "</span>ERROR</span>",</span> error</span>:</span> e</span> }</span>;</span></span>
    }</span></span>
  }</span>)()</span>;</span></span>
</span>
  return</span> ()</span> =></span> {</span></span>
    switch</span> (state</span>.</span>status)</span> {</span></span>
      case</span> "</span>PENDING</span>":</span></span>
        throw</span> pendingPromise</span>;</span></span>
      case</span> "</span>ERROR</span>":</span></span>
        throw</span> state</span>.</span>error</span>;</span></span>
      case</span> "</span>SUCCESS</span>":</span></span>
        return</span> state</span>.</span>data</span>;</span></span>
    }</span></span>
  }</span>;</span></span>
}</span></span></code></pre>
It fires the promise and then returns a function that will fetch the data, if it's available.
And if it's not, it just throws the promise</em>. That's it, that's the magic. Suspense</code> then will
act like an error boundary</a> and catch the promise
and then do whatever it is that it does to promises. Presumably await them and then retry with
the rendering roughly when they're done.</p>
This is the part where I pretend to know what algebraic effects are and say, gosh, this looks a lot
like algebraic effects.</p>
I grew to like fetching in useEffect, but I won't deny it's always looked a bit awkward, so I'm glad
this deprecates it. I'm also glad this makes the API synchronous, because it means that error
boundaries are finally useful. To be frank, I haven't implemented error handling in the data-fetching
component I use in another app because if the request returns an error it can only mean the server
is down, and that's a scenario I don't really want to entertain. That and the API wouldn't make
it very pleasant to deal with errors.</p>
I don't know what to make of useTransition</code> yet, but I think I'll write another post about it when
I figure it out. This is just a braindump of what I gathered so far.</p>
Another thought</h2>
One thing I've learnt is that you have</em> to read from the resource in a different component than
the one you use Suspense</code> in, so you can't inline Hello into SuspendTest.</p>
const</span> SuspendTest</span> =</span> ()</span> =></span> {</span></span>
  const</span> resource</span> =</span> suspendPromise</span>(</span>async</span> ()</span> =></span> {</span></span>
    await</span> sleep</span>(</span>3000</span>)</span>;</span></span>
    return</span> "</span>from inside a shell</span>"</span>;</span></span>
  }</span>)</span>;</span></span>
</span>
  return</span> (</span></span>
    <</span>Suspense fallback</span>=</span>"</span>loading...</span>"</span>></span></span>
      <span></span>Hello </span>{</span>resource</span>()</span>}</span></span> // Bad!</span></span>
    </</span>Suspense</span>></span></span>
  )</span>;</span></span>
}</span>;</span></span></code></pre>
And I'm wondering how they will enforce this. Probably just with some error messages and
a slap on the wrist like "the rules of hooks".</p>

The full code for this post is available on CodeSandbox</a>.</p>


Config constraints in the type system where they belong
steen — Tue, 17 Sep 2019 00:00:00 +0000
Suppose we're maintaining a frontend application. This application has to work
across different sites, each identified by a triplet of name, language and country.
Let us have a type for that.</p>
interface</span> Site</span> {</span></span>
  name</span>:</span> string</span>;</span></span>
  language</span>:</span> string</span>;</span></span>
  country</span>:</span> string</span>;</span></span>
}</span></span></code></pre>
Our coworker Homer passes by and looks at our code.</p>
This is good enough, he might say, and we know he's wrong. We have a list of all the
site names and supported locales ready to be used. What the hell is a string?, we ask him.
Is the empty string a valid site name? Is "dddsdsddddssddsdsd" a valid language?
Is Wales a country? Does the pope shit in the woods?</p>
type</span> SiteName</span> =</span> "</span>scylla</span>"</span> |</span> "</span>charybdis</span>"</span>;</span></span>
type</span> Language</span> =</span> "</span>it</span>"</span> |</span> "</span>de</span>"</span> |</span> "</span>el</span>"</span> |</span> "</span>hr</span>"</span>;</span></span>
type</span> Country</span> =</span> "</span>IT</span>"</span> |</span> "</span>CH</span>"</span> |</span> "</span>GR</span>"</span> |</span> "</span>HR</span>"</span>;</span></span>
</span>
interface</span> Site</span> {</span></span>
  name</span>:</span> SiteName</span>;</span></span>
  language</span>:</span> Language</span>;</span></span>
  country</span>:</span> Country</span>;</span></span>
}</span></span></code></pre>
Only there's a catch: not all sites support all locales, and not all locales are valid.
In fact we have a list of all the possible permutations of these three parameters.
I have it on good authority that people in Italy don't speak Greek, and yet the type of
Site</code> says otherwise. How can we sleep at night knowing that one day Homer could just
wake up and go add a site with locale el_IT</code>?</p>
type</span> SiteName</span> =</span> "</span>scylla</span>"</span> |</span> "</span>charybdis</span>"</span>;</span></span>
type</span> Language</span> =</span> "</span>it</span>"</span> |</span> "</span>de</span>"</span> |</span> "</span>el</span>"</span> |</span> "</span>hr</span>"</span>;</span></span>
type</span> Country</span> =</span> "</span>IT</span>"</span> |</span> "</span>CH</span>"</span> |</span> "</span>GR</span>"</span> |</span> "</span>HR</span>"</span>;</span></span>
</span>
interface</span> S</span><</span>N</span> extends</span> SiteName</span>,</span> L</span> extends</span> Language</span>,</span> C</span> extends</span> Country</span>> {</span></span>
  name</span>:</span> N</span>;</span></span>
  language</span>:</span> L</span>;</span></span>
  country</span>:</span> C</span>;</span></span>
}</span></span>
</span>
type</span> Site</span> =</span></span>
  |</span> S</span><"</span>scylla</span>", "</span>it</span>", "</span>IT</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>el</span>", "</span>GR</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>de</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>it</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span></code></pre>
Now we have an issue: if we were to add a new language, say "fr", we'd have to add it
in two places, and too much typing is bad for our wrists. Let us reduce the risk
of carpal tunnel.</p>
interface</span> S</span><</span>SiteName</span>,</span> Language</span>,</span> Country</span>> {</span></span>
  name</span>:</span> SiteName</span>;</span></span>
  language</span>:</span> Language</span>;</span></span>
  country</span>:</span> Country</span>;</span></span>
}</span></span>
</span>
type</span> Site</span> =</span></span>
  |</span> S</span><"</span>scylla</span>", "</span>it</span>", "</span>IT</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>el</span>", "</span>GR</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>de</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>fr</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>it</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
</span>
type</span> SiteName</span> =</span> Site</span>[</span>"</span>name</span>"</span>]</span>;</span></span>
type</span> Language</span> =</span> Site</span>[</span>"</span>language</span>"</span>]</span>;</span></span>
type</span> Country</span> =</span> Site</span>[</span>"</span>country</span>"</span>]</span>;</span></span></code></pre>
Much better. Our wrists rejoice.</p>
Now suppose we have a feature that we only want to see on scylla, so we only want to handle
the locales that are supported on scylla. TS defines a utility types that does just that
called Extract</code>, so let us define some utility types for that.</p>
type</span> SitesByName</span><</span>N</span> extends</span> SiteName</span>></span> =</span> Extract</span><</span>Site</span>, {</span> name</span>:</span> N</span> }></span>;</span></span>
</span>
type</span> _1</span> =</span> SitesByName</span><"</span>scylla</span>"></span>[</span>"</span>country</span>"</span>]</span>;</span> // "IT" | "GR" | "HR"</span></span></code></pre>
We also want to have a string representation of each site, so we can use it as key in
an object for features that have a different behavior on each sites. This is a bit boilerplatey,
but sadly necessary.</p>
type</span> SiteString</span> =</span></span>
  |</span> "</span>scylla|it_IT</span>"</span></span>
  |</span> "</span>scylla|el_GR</span>"</span></span>
  |</span> "</span>scylla|hr_HR</span>"</span></span>
  |</span> "</span>charybdis|de_CH</span>"</span></span>
  |</span> "</span>charybdis|fr_CH</span>"</span></span>
  |</span> "</span>charybdis|it_CH</span>"</span></span>
  |</span> "</span>charybdis|hr_HR</span>"</span>;</span></span></code></pre>
We also need some function to convert a Site</code> to and from a SiteString</code>, but if we
were to do it with just these types we'd be losing precious type information in the
process! We surely don't want that. We need some sort of conversion table.</p>
interface</span> SiteOfString</span> {</span></span>
  "</span>scylla|it_IT</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>it</span>", "</span>IT</span>"></span>;</span></span>
  "</span>scylla|el_GR</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>el</span>", "</span>GR</span>"></span>;</span></span>
  "</span>scylla|hr_HR</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
  "</span>charybdis|de_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>de</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|fr_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>fr</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|it_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>it</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|hr_HR</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
}</span></span>
</span>
type</span> SiteString</span> = keyof</span> SiteOfString</span>;</span></span>
</span>
type</span> _2</span> =</span> SiteOfString</span>[</span>"</span>scylla|hr_HR</span>"</span>]</span>;</span> // S<"scylla", "hr", "HR"></span></span></code></pre>
Once again we can derive the union we wrote above from this table to save us a bit of typing.
We still need to be very careful to keep Site</code> and SiteOfString</code> in sync, because
debugging a type error deriving from one of those could easily get confusing.</p>
Now let us implement the function to parse a SiteString</code> into a Site</code>.</p>
Content warning: unsafe type assertions</strong></p>
export const</span> parseSiteString</span> =</span> <</span>SS</span> extends</span> SiteString</span>></span>(</span></span>
  siteString</span>:</span> SS</span></span>
)</span>:</span> SiteOfString</span>[</span>SS</span>]</span> =></span> {</span></span>
  const</span> [,</span> name</span>,</span> language</span>,</span> country</span>]</span> =</span> siteString</span>.</span>match</span>(</span></span>
    /([</span>a-z</span>]</span>+</span>)</span>\|</span>([</span>a-z</span>]</span>+</span>)</span>_</span>([</span>A-Z</span>]</span>+</span>)/</span></span>
  )</span>! as</span> any</span>[]</span>;</span></span>
  return</span> {</span> name</span>,</span> language</span>,</span> country</span> }</span>;</span></span>
}</span>;</span></span>
</span>
parseSiteString</span>(</span>"</span>scylla|hr_HR</span>"</span>)</span>;</span> // S<"scylla", "hr", "HR"></span></span></code></pre>
The two assertions make us sick to the stomach, but after adding a few tests we feel better enough
to move onwards. Seeing the function convert the string with 0 type information loss really is its
own reward.</p>
The reverse is a bit trickier, but fortunately the very nice typelevel-ts</a>
library already has a similar type we can look up to help us on our journey to enlightenment, namely KeysOfType</code>.</p>

KeysOfType</code>: Picks only the keys of a certain type</p>
</blockquote>
export type KeysOfType<A extends object, B> = { [K in keyof A]-?: A[K] extends B ? K : never }[keyof A]</span></span></code></pre>
Let us adapt it for our use case.</p>
export type</span> StringOfSite</span><</span>S</span> extends</span> Site</span>></span> =</span> {</span></span>
  [</span>K</span> in</span> SiteString</span>]</span>:</span> SiteOfString</span>[</span>K</span>][</span>"</span>name</span>"</span>]</span> extends</span> S</span>[</span>"</span>name</span>"</span>]</span> ?</span> K</span> :</span> never</span></span>
}</span>[</span>SiteString</span>]</span>;</span></span>
</span>
type</span> _3</span> =</span> StringOfSite</span><</span>S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>">></span>;</span></span>
// "scylla|it_IT" | "scylla|el_GR" | "scylla|hr_HR"</span></span></code></pre>
But that only returns the SiteString</code>s with the same name, we hear a voice crying behind us.
Patience, Homer. Design is an iterative process, and so let us iterate on the result
of this first type with the other two parameters.</p>
export type</span> StringOfSite</span><</span>S</span> extends</span> Site</span>></span> =</span> {</span></span>
  [</span>K</span> in</span> SiteString</span>]</span>:</span> SiteOfString</span>[</span>K</span>][</span>"</span>name</span>"</span>]</span> extends</span> S</span>[</span>"</span>name</span>"</span>]</span></span>
    ?</span> SiteOfString</span>[</span>K</span>][</span>"</span>language</span>"</span>]</span> extends</span> S</span>[</span>"</span>language</span>"</span>]</span></span>
      ?</span> SiteOfString</span>[</span>K</span>][</span>"</span>country</span>"</span>]</span> extends</span> S</span>[</span>"</span>country</span>"</span>]</span></span>
        ?</span> K</span></span>
        :</span> never</span></span>
      :</span> never</span></span>
    :</span> never</span></span>
}</span>[</span>SiteString</span>]</span>;</span></span>
</span>
export const</span> serializeSite</span> =</span> <</span>S</span> extends</span> Site</span>></span>(</span>{</span></span>
  name</span>,</span></span>
  language</span>,</span></span>
  country</span></span>
}</span>:</span> S</span>)</span> =></span> `${</span>name</span>}</span>|</span>${</span>language</span>}</span>_</span>${</span>country</span>}`</span> as</span> StringOfSite</span><</span>S</span>></span>;</span></span>
</span>
serializeSite</span>(</span>{</span> name</span>: "</span>charybdis</span>",</span> language</span>: "</span>de</span>",</span> country</span>: "</span>CH</span>" }</span>)</span>;</span></span>
// "charybdis|de_CH"</span></span></code></pre>
That'll do, pig. That'll do.</p>

You probably shouldn't use this kind of type-level hackery on a production application.
But you might get away with it if you use a type-level testing library like
dtslint</a> or
conditional-type-checks</a>.</p>
Here's the full source code, ready to be pasted in your editor or on
TypeScript's playground</a>.</p>
interface</span> S</span><</span>SiteName</span>,</span> Language</span>,</span> Country</span>> {</span></span>
  name</span>:</span> SiteName</span>;</span></span>
  language</span>:</span> Language</span>;</span></span>
  country</span>:</span> Country</span>;</span></span>
}</span></span>
</span>
type</span> Site</span> =</span></span>
  |</span> S</span><"</span>scylla</span>", "</span>it</span>", "</span>IT</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>el</span>", "</span>GR</span>"></span></span>
  |</span> S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>de</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>fr</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>it</span>", "</span>CH</span>"></span></span>
  |</span> S</span><"</span>charybdis</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
</span>
type</span> SiteName</span> =</span> Site</span>[</span>"</span>name</span>"</span>]</span>;</span></span>
type</span> Language</span> =</span> Site</span>[</span>"</span>language</span>"</span>]</span>;</span></span>
type</span> Country</span> =</span> Site</span>[</span>"</span>country</span>"</span>]</span>;</span></span>
</span>
type</span> SitesByName</span><</span>N</span> extends</span> SiteName</span>></span> =</span> Extract</span><</span>Site</span>, {</span> name</span>:</span> N</span> }></span>;</span></span>
</span>
interface</span> SiteOfString</span> {</span></span>
  "</span>scylla|it_IT</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>it</span>", "</span>IT</span>"></span>;</span></span>
  "</span>scylla|el_GR</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>el</span>", "</span>GR</span>"></span>;</span></span>
  "</span>scylla|hr_HR</span>"</span>:</span> S</span><"</span>scylla</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
  "</span>charybdis|de_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>de</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|fr_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>fr</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|it_CH</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>it</span>", "</span>CH</span>"></span>;</span></span>
  "</span>charybdis|hr_HR</span>"</span>:</span> S</span><"</span>charybdis</span>", "</span>hr</span>", "</span>HR</span>"></span>;</span></span>
}</span></span>
</span>
type</span> SiteString</span> = keyof</span> SiteOfString</span>;</span></span>
</span>
export const</span> parseSiteString</span> =</span> <</span>SS</span> extends</span> SiteString</span>></span>(</span></span>
  siteString</span>:</span> SS</span></span>
)</span>:</span> SiteOfString</span>[</span>SS</span>]</span> =></span> {</span></span>
  const</span> [,</span> name</span>,</span> language</span>,</span> country</span>]</span> =</span> siteString</span>.</span>match</span>(</span></span>
    /([</span>a-z</span>]</span>+</span>)</span>\|</span>([</span>a-z</span>]</span>+</span>)</span>_</span>([</span>A-Z</span>]</span>+</span>)/</span></span>
  )</span>! as</span> any</span>[]</span>;</span></span>
  return</span> {</span> name</span>,</span> language</span>,</span> country</span> }</span>;</span></span>
}</span>;</span></span>
</span>
export type</span> StringOfSite</span><</span>S</span> extends</span> Site</span>></span> =</span> {</span></span>
  [</span>K</span> in</span> SiteString</span>]</span>:</span> SiteOfString</span>[</span>K</span>][</span>"</span>name</span>"</span>]</span> extends</span> S</span>[</span>"</span>name</span>"</span>]</span></span>
    ?</span> SiteOfString</span>[</span>K</span>][</span>"</span>language</span>"</span>]</span> extends</span> S</span>[</span>"</span>language</span>"</span>]</span></span>
      ?</span> SiteOfString</span>[</span>K</span>][</span>"</span>country</span>"</span>]</span> extends</span> S</span>[</span>"</span>country</span>"</span>]</span> ?</span> K</span> :</span> never</span></span>
      :</span> never</span></span>
    :</span> never</span></span>
}</span>[</span>SiteString</span>]</span>;</span></span>
</span>
export const</span> serializeSite</span> =</span> <</span>S</span> extends</span> Site</span>></span>(</span>{</span></span>
  name</span>,</span></span>
  language</span>,</span></span>
  country</span></span>
}</span>:</span> S</span>)</span> =></span> `${</span>name</span>}</span>|</span>${</span>language</span>}</span>_</span>${</span>country</span>}`</span> as</span> StringOfSite</span><</span>S</span>></span>;</span></span></code></pre>


A brief history of JAVAScript
steen — Fri, 30 Aug 2019 00:00:00 +0000
JAVAScript is often described as a superset of JSon. This is only half the truth.</p>
Back in 1996 when the Internet was being designed by Tim Bernard-Lee, he reportedly received a visit from St. Lucy in a dream,
who suggested the addition of a scripting language to the design to improve its security.
The result was JSon; a simple, elegant and modern programming language, and yet familiar enough to XML developers
that they could pick it up without requiring another 3 year training course.</p>
(Fun fact: Larry Brim, the author of the language spec, wanted to name the language after his son J.
Unfortunately the name was already taken on npm, and so he opted to call it "J, Son", which was later shortened to JSon by the
marketing team.)</p>
The addition of JSon to the design of the Internet delayed its release by a few months. Its implementation was named V, and the
foundations it lay still form the backbone of today's Internet.</p>
When the Internet was finally released and made accessible to the public through Chrome in 1998,
the response to JSon was lukewarm. Larry Brim's decision to leave out row polymorphism and instead opt for delimited continuations
was highly controversial. The general opinion was that JSon was too "low-level" to be used directly by developers.</p>
This led to the development of several languages which compiled to JSon, the most notable being Yaml (Oracle, 2002),
a very powerful and expressive language whose primary features included significant whitespace and arbitrary code execution,
and Java (Comcast, 2003), a light superset of JSon which brought back row polymorphism and enabled the development of Applets.</p>
Tight collaboration between the creators of these new languages and the V development team prompted the addition of a lot of
new constructs and instructions that enabled the creators to optimize common workflows, and in an interview from 2008, 10 years after its
initial release, Larry Brim declared that the specification of JSon was growing to the point where he may not be able to contain it.</p>
Version 7 of V, often abbreviated to V7, would be the last version to support JSon as compilation target. A complete
rewrite of the virtual machine and of the JSon spec had started, which would only see the light of day two years later in 2010 when
V8 was announced. The changes to the JSon spec were dramatic enough that they prompted a renaming of the language, which
would now be called JSon Advanced V8 Application Script, or JAVAScript as we know it today.</p>
JAVAScript was well received by the community, and has largely replaced JSon as the Internet's leading scripting language. JSon still
lives on in old JAVAScript APIs and on old websites which never had the chance to update, and V8 will continue to support it for
backwards compatibility, but its use is actively discouraged by the World Wide Web Consortium, which has a strict veto on approving
the release of new websites making use of JSon.</p>


A data-fetching component in React
steen — Fri, 10 May 2019 00:00:00 +0000
Remember last year's talk</a> about Suspense by Dan Abramov?
I was still mostly learning React when that was uploaded to youtube, and
seeing him talk about just this issue and presenting this magic API that
seemed to solve it without much effort got me really hooked.
But then Suspense</a> actually comes out and (even an year
later) it's just about code splitting. What gives?</p>
Fast forward one year, I was refactoring parts of a smallish React app and
taking the opportunity to learn hooks, and I noticed I had a lot of components
that shared roughly this structure (plus some unrelated UI state sprinkled in
for good measure):</p>
class</span> CookieCutter</span> extends</span> React</span>.</span>Component</span> {</span></span>
  state</span> =</span> {</span></span>
    hasLoaded</span>:</span> false</span>,</span></span>
    data</span>:</span> null</span>,</span></span>
  }</span>;</span></span>
</span>
  componentDidMount</span>() {</span></span>
    this</span>.</span>props</span>.</span>fetchData</span>()</span>.</span>then</span>(</span>(</span>data</span>)</span> =></span> {</span></span>
      this</span>.</span>setState</span>(</span>{</span></span>
        hasLoaded</span>:</span> true</span>,</span></span>
        data</span>,</span></span>
      }</span>)</span>;</span></span>
    }</span>)</span>;</span></span>
  }</span></span>
</span>
  render</span>() {</span></span>
    const</span> {</span> hasLoaded</span>,</span> data</span> }</span> = this</span>.</span>state</span>;</span></span>
</span>
    return</span> hasLoaded</span> ?</span> (</span></span>
      <div>{</span>data</span>}</div></span></span>
    )</span> :</span> (</span></span>
      <div></span>Loading...</span></div></span></span>
    )</span>;</span></span>
  }</span></span>
}</span></span></code></pre>
And since I had just spent all day decomposing old monstrous class components
and otherwise wasting time polishing parts of the app like an art project,
I started thinking about how I could extract this pattern so it would look like
the vague memory I had of Suspense. For reference, this (part of) Suspense's
API:</p>
<</span>Suspense fallback</span>={<div></span>Loading...</span></div>}></span></span>
  <</span>NewComfort</span> /></span></span>
</</span>Suspense</span>></span></span></code></pre>
Something kind of bothers me about this API: where's the data? How does
Suspense</code> know that whatever data NewComfort</code> needs has finished loading?
It looks like the data flows downwards from NewComfort</code>, but also upwards
towards Suspense</code>? I guess I'm just not used to this stuff, but I thought
it'd be better to be a bit more explicit, even if it increased verbosity.
I'm also not a huge fan of higher-order components, so instead I decided to
rely on the good old trick of render props</a>.</p>
<</span>LazyLoaded</span></span>
  provider</span>={</span>fetchData</span>}</span></span>
  fallback</span>={<div></span>Loading...</span></div>}</span></span>
></span></span>
  {</span>(</span>data</span>)</span> =></span> (</span></span>
    <</span>ChocolateMatter data</span>={</span>data</span>} /></span></span>
  )</span>}</span></span>
</</span>LazyLoaded</span>></span></span></code></pre>
LazyLoaded</code> is probably not a very good name, but I decided to go with that.
I was still on the hooks hype train so I went out of my way to implement it
using hooks:</p>
interface</span> Props</span><</span>T</span>> {</span></span>
  provider</span>:</span> ()</span> =></span> Promise</span><</span>T</span>></span>;</span></span>
  fallback</span>?:</span> JSX</span>.</span>Element</span>;</span></span>
  children</span>:</span> (</span>data</span>:</span> T</span>)</span> =></span> JSX</span>.</span>Element</span> |</span> null</span>;</span></span>
}</span></span>
</span>
export function</span> LazyLoaded</span><</span>T</span>>({</span></span>
  provider</span>,</span></span>
  fallback</span>,</span></span>
  children</span></span>
}</span>:</span> Props</span><</span>T</span>>) {</span></span>
  const</span> [</span>data</span>,</span> setData</span>]</span> =</span> React</span>.</span>useState</span><</span>T</span> |</span> null</span>></span>(</span>null</span>)</span>;</span></span>
</span>
  React</span>.</span>useLayoutEffect</span>(</span>()</span> =></span> {</span></span>
    setData</span>(</span>null</span>)</span>;</span></span>
    provider</span>()</span>.</span>then</span>(</span>(</span>data</span>)</span> =></span> {</span></span>
      setData</span>(data)</span>;</span></span>
    }</span>)</span>;</span></span>
  },</span> [provider])</span>;</span></span>
</span>
  return</span> data</span> ?</span> children</span>(data)</span> :</span> fallback</span> || null;</span></span>
}</span></span></code></pre>
And this worked well enough. At first I implemented it using useEffect</code>, but I
noticed that useLayoutEffect</code> would actually skip the split-second load that
occurred when the provider</code> resolved immediately if the data was already in
the cache.</p>
But there's a big issue with this implementation. Do you see it? I didn't until
I actually tested the component on the real page. Consider this:</p>
type</span> Page</span> =</span> '</span>VELOCITY</span>'</span> |</span> '</span>DESIGN</span>'</span> |</span> '</span>COMFORT</span>'</span>;</span></span>
</span>
const</span> Main</span> =</span> ({</span> cache</span> })</span> =></span> {</span></span>
  const</span> [</span>page</span>,</span> setPage</span>]</span> =</span> React</span>.</span>useState</span><</span>Page</span>></span>(</span>'</span>VELOCITY</span>'</span>)</span>;</span></span>
</span>
  return</span> (</span></span>
    <div></span></span>
      {</span>page</span> ===</span> '</span>VELOCITY</span>'</span> ?</span> (</span></span>
        <</span>LazyLoaded</span></span>
          provider</span>={</span>cache</span>.</span>getTekka</span>}</span></span>
          fallback</span>={<div></span>Loading tekka...</span></div>}</span></span>
        ></span></span>
          {</span>(</span>data</span>)</span> =></span> (</span></span>
            <</span>Velocity data</span>={</span>data</span>}</span> setPage</span>={</span>setPage</span>} /></span></span>
          )</span>}</span></span>
        </</span>LazyLoaded</span>></span></span>
      )</span> :</span> page</span> ===</span> '</span>DESIGN</span>'</span> ?</span> (</span></span>
        <</span>LazyLoaded</span></span>
          provider</span>={</span>cache</span>.</span>getDsco</span>}</span></span>
          fallback</span>={<div></span>Loading dsco...</span></div>}</span></span>
        ></span></span>
          {</span>(</span>data</span>)</span> =></span> (</span></span>
            <</span>Design data</span>={</span>data</span>}</span> setPage</span>={</span>setPage</span>} /></span></span>
          )</span>}</span></span>
        </</span>LazyLoaded</span>></span></span>
      )</span> :</span> (</span></span>
        <</span>Comfort setPage</span>={</span>setPage</span>} /></span></span>
      )</span>}</span></span>
    </div></span></span>
  )</span>;</span></span>
}</span>;</span></span></code></pre>
We land on'VELOCITY'</code> and switch to 'COMFORT'</code> and then to 'DESIGN'</code> and
everything is good. But then from 'DESIGN'</code> we switch the page back to
'VELOCITY'</code> and everything breaks. What just happened?</p>
To understand this, you should know a bit about what React calls
reconciliation</a>. To ensure that the whole page isn't
unmounted and remounted every time something changes, React will look at the
component tree and do some diffing to make sure that only what actually needs
to be updated will be.</p>
In particular, React will look at the "type" of component, and if it remains
the same between two updates it will avoid unmounting and remounting it. In
this case this is pretty bad news, because when we switch between the two
pages above that have a LazyLoaded component at the same level of the render
tree, LazyLoaded</code> will not not</em> get unmounted. In the first paint we end up
with an invalid state in which the children</code> function is the new one from
'VELOCITY'</code>, but the data</code> is the old one we fetched in 'DESIGN'</code>.</p>
So how do we fix it? The first and dumbest thing that came into mind was make
sure that LazyLoaded</code> is unmounted whenever we change the page. React
provides a default prop on all components that just about does this this
called key</code>.</p>
page</span> ===</span> '</span>VELOCITY</span>'</span> ?</span> (</span></span>
  <</span>LazyLoaded</span></span>
    key</span>=</span>"</span>VELOCITY</span>"</span></span>
    provider</span>={</span>cache</span>.</span>getTekka</span>}</span></span>
    fallback</span>={<div></span>Loading tekka...</span></div>}</span></span>
  ></span></span>
    {</span>(</span>data</span>)</span> =></span> (</span></span>
      <</span>Velocity data</span>={</span>data</span>}</span> setPage</span>={</span>setPage</span>} /></span></span>
    )</span>}</span></span>
  </</span>LazyLoaded</span>></span></span>
)</span> :</span> page</span> ===</span> '</span>DESIGN</span>'</span> ?</span> (</span></span>
  <</span>LazyLoaded</span></span>
    key</span>=</span>"</span>DESIGN</span>"</span></span>
    provider</span>={</span>cache</span>.</span>getDsco</span>}</span></span>
    fallback</span>={<div></span>Loading dsco...</span></div>}</span></span>
  ></span></span>
    {</span>(</span>data</span>)</span> =></span> (</span></span>
      <</span>Design data</span>={</span>data</span>}</span> setPage</span>={</span>setPage</span>} /></span></span>
    )</span>}</span></span>
  </</span>LazyLoaded</span>></span></span>
)</span> :</span> (</span></span>
  <</span>Comfort setPage</span>={</span>setPage</span>} /></span></span>
)</span></span></code></pre>
By making key</code> required in LazyLoaded</code>'s prop type and adding a threatening
doc comment I more or less ensured that users of this component would always
add a "reasonably unique" key</code> for the part of the render tree LazyLoaded</code>
would be used in. And this worked well and things were good.</p>
It's kind of a hack though, so the other day I came back to this component and
deleted both the key from the prop type and the threatening comment.
Considering the relationship between all the bits that form the state of the
component, it becomes obvious that a certain data</code> can only be associated
with the children</code> function from the render from which we also got the data's
provider</code>. With that in mind, we should modify the component a bit:</p>
interface</span> State</span><</span>T</span>> {</span></span>
  data</span>:</span> T</span>;</span></span>
  childrenSync</span>:</span> (</span>data</span>:</span> T</span>)</span> =></span> JSX</span>.</span>Element</span> |</span> null</span>;</span></span>
}</span></span>
</span>
export function</span> LazyLoaded</span><</span>T</span>>({</span></span>
  provider</span>,</span></span>
  fallback</span>,</span></span>
  children</span></span>
}</span>:</span> Props</span><</span>T</span>>) {</span></span>
  const</span> [</span>state</span>,</span> setState</span>]</span> =</span></span>
    React</span>.</span>useState</span><</span>State</span><</span>T</span>></span> |</span> null</span>></span>(</span>null</span>)</span>;</span></span>
</span>
  React</span>.</span>useLayoutEffect</span>(</span>()</span> =></span> {</span></span>
    setState</span>(</span>null</span>)</span>;</span></span>
    provider</span>()</span>.</span>then</span>(</span>(</span>data</span>)</span> =></span> {</span></span>
      setState</span>(</span>{</span></span>
        data</span>,</span></span>
        childrenSync</span>:</span> children</span>,</span></span>
      }</span>)</span>;</span></span>
    }</span>)</span>;</span></span>
  },</span> [provider])</span>;</span></span>
</span>
  return</span> state</span></span>
    ?</span> state</span>.</span>childrenSync</span>(state</span>.</span>data)</span></span>
    :</span> fallback</span> || <</span>Loading</span> />;</span></span>
}</span></span></code></pre>
Remember that, being a closure, the useLayoutEffect callback will capture the
value of children</code> at the time it is defined, so since we defined our types
correctly we can be sure that the value returned from the provider</code> will
always match the one expected from the children</code>.</p>
And now everything is good again. (The error handling and cancellation in this
component are left as an exercise to the reader.)</p>
I really like this pattern, but I haven't found anything similar to it online
when I searched. Maybe I'm just looking in the wrong places? Or maybe other
people that came up with this thought it was too simple to warrant writing
about it? Nevertheless, I thought it was worth sharing because it's nice and
presented a problem with a non-obvious solution, unless you're familiar with
some of React's internal workings. Maybe somebody will get a kick out of this.</p>


Reading Ur/Web signatures, part 1
steen — Mon, 07 Jan 2019 00:00:00 +0000
So you stumbled upon Ur/Web and you rather like what it's about, but after
trudging through the tutorials and the examples in the few blog posts you've
seen around you can't seem to find your own footing. The compiler errors are
long and life is short and you're about to throw your computer out the window.</p>
I understand.</a></p>
In this post, I'll walk you through the signatures of a few functions from the
standard library, hopefully providing you with enough context to make it
through the rest on your own. You might want to grab a copy</a> or search
for the one on your hard drive so you can follow along.</p>
I'm going to be frank: given the current state of the ecosystem and of the
documentation, you have close to no chance of learning Ur/Web if you don't
already know some OCaml/ReasonML or another language in the ML family, so
if you don't you might want to get well acquainted with one first.
Elm</a> is a good starting point.</p>
Open up string.urs</code> and have a look around. I'm going to assume you can read
these signatures:</p>
type</span> t</span> =</span> string</span></span>
</span>
val</span> length</span> :</span> t</span> -></span> int</span></span>
</span>
val</span> append</span> :</span> t</span> -></span> t</span> -></span> t</span></span>
</span>
val</span> all</span> :</span> (</span>char</span> -></span> bool</span>)</span> -></span> string</span> -></span> bool</span></span></code></pre>
Still here? Good, let's introduce some new syntax.</p>
val</span> index</span> :</span> string</span> -></span> char</span> -></span> option</span> int</span></span></code></pre>
If you come from OCaml or SML you might notice that the argument of the type
constructor option</code> is to the right of the constructor, as in normal function
application. This unification of function and type constructor application is
not just a matter of syntax like in ReasonML</a>; put this in the
back of your mind for the moment, we'll come back to it later.</p>
val</span> substring</span> :</span> string</span> -></span> {</span>Start </span>:</span> int</span>,</span> Len </span>:</span> int</span>}</span> -></span> string</span></span></code></pre>
Much like SML, Ur/Web makes up for the lack of labeled arguments by using
anonymous records as function arguments. Also, record field names must start
with a capital letter like the members of a variant.</p>
Generics</h2>
Let's kick things up a notch. Open up list.urs</code> and you'll be greeted by
something like this:</p>
val</span> rev</span> :</span> a</span> :::</span> Type </span>-></span> list</span> a</span> -></span> list</span> a</span></span></code></pre>
As you might have guessed, List.rev</code> is a function that takes a list of
elements and returns another list with the elements of the first, in reverse
order. rev</code> can reverse lists that contain any element, so we say that it is
polymorphic</em>.</p>
a</code> is the type of the values contained in the input and output list. The
argument a ::: Type</code> is just a way of saying that we don't know what type a</code>
will be when we declare the function; it's up to the caller to bind it to a
valid type. The triple colon (:::</code>) means that this type parameter is
implicit, so the compiler will take care of inserting the correct type when
calling it.</p>
OCaml and most other languages don't require you to explicitly declare these
type parameter, but sometimes it is useful</a> to ensure the
well-typedness of a polymorphic function.</p>
Quoting from the tutorial</a>:</p>

Unlike in ML and Haskell, polymorphic functions in Ur/Web often require full
type annotations. That is because more advanced features make Ur type
inference undecidable.</p>
</blockquote>
Let's pull up the implementation for a moment (found in list.ur</code>):</p>
fun rev [a] (ls : list a) = ...</span></span></code></pre>
The a</code> in square brackets here corresponds to a ::: Type</code> in the signature
above. We could also write it like [a ::: Type]</code> if we wanted to be more
explicit.</p>
Now let's look at List.mp</code>. (Which is just the List.map</code> function, but it
can't be called map</code> because map</code> is a keyword in Ur/Web. More on that later.)</p>
val</span> mp</span> :</span> a</span> :::</span> Type </span>-></span> b</span> :::</span> Type </span>-></span> (</span>a</span> -></span> b</span>)</span> -></span> list</span> a</span> -></span> list</span> b</span></span></code></pre>
mp</code> has two polymorphic type parameters, so they are both made explicit in
the signature.</p>
Interestingly, we can write a function so that the type parameter has to be
passed explicitly</em> by replacing :::</code> with a double colon (::</code>):</p>
(*</span> id.urs </span>*)</span></span>
val</span> id</span> :</span> a</span> ::</span> Type </span>-></span> a</span> -></span> a</span></span>
</span>
(*</span> id.ur </span>*)</span></span>
fun </span>id</span> [a :: Type]</span> (</span>x</span> :</span> a)</span> =</span> x</span></span>
</span>
val x</span> =</span> id [int] 451</span></span></code></pre>
:::</code> indicates a type parameter that may be inferred by the compiler, while
::</code> indicates one that has to be passed explicitly. The compiler will be able
to infer a type parameter by itself most of the time, but in some cases which
we'll see later you'll have to be explicit and use the double colon.</p>
Basics of type constructors</h2>
At this point I should introduce Ur/Web's type constructors, because they're
a lot more powerful than those in most other languages. Open up json.ur</code>
(not json.urs</code>) and the first thing you'll see will be this:</p>
con json a = {ToJson : a -> string,</span></span>
              FromJson : string -> a * string}</span></span></code></pre>
While the con</code> keyword might throw you off, you might recognize this as a
simple type declaration. Ur/Web actually makes a distinction between simple
aliases, like the one we encountered at the top of string.urs</code>, and type
constructors, which take one (or more!) arguments, and have to be declared
with the keyword con</code>.</p>
The json</code> type constructor is simply a record with an encoder function which
takes an a</code> and returns a JSON string, and a decoder function which takes a
JSON string and returns an a</code> and the remaining JSON string.</p>
Remember that thing earlier about unifying function application and type
constructor application syntax? The two are actually very closely related:
just as normal functions are functions from values to values, type constructors
can be thought of as type-level functions from types to types</strong>, and the
purpose of this unification is just to make the similarity more apparent.</p>
This insight might not net you much in OCaml or SML because type constructors
have a lot of limitations compared to functions: they can't be curried, and
you can perform very few operations inside them.</p>
Ur/Web's type constructors are much more interesting. The json</code> declaration
above is actually syntactic sugar for a type-level function:</p>
con json = fn (a :: Type) =></span></span>
  {ToJson : a -> string,</span></span>
   FromJson : string -> a * string}</span></span></code></pre>
We can define a curried</strong> constructor that takes two types and returns the
type of a 2-tuple:</p>
con pair a b = a * b</span></span>
</span>
con intAnd :: Type -> Type = pair int</span></span>
</span>
val</span> p</span> :</span> intAnd</span> string</span> =</span> (</span>451</span>,</span> "what a shame"</span>)</span></span></code></pre>
We can also perform various useful operations on record types, as we'll see
later.</p>
Type classes</h2>
Ur/Web's =</code> (equals) operator works just like you'd expect it to for types
provived by the standard library: 1 = 1</code>, "line" = "line"</code>,
and Some "just" = Some "just"</code>. So is it implemented like in OCaml</a>,
using a "magic" internal function that structurally compares record fields
and variant members? Not quite.</p>
If we try to compare two records, we'll get a surprisingly helpful error
message:</p>
(*</span> test.ur </span>*)</span></span>
val</span> ok</span> = {</span> A </span>=</span> 1</span> }</span> =</span> {</span> A </span>=</span> 1</span> }</span></span>
</span>
(*</span> test.ur:1:5: (to 1:26) Can't resolve type class instance</span></span>
   Class constraint: eq {A : int} </span>*)</span></span></code></pre>
Let's take a look into basis.urs</code>. At line 26, you'll see these declarations:</p>
class</span> eq</span></span>
val</span> eq</span> :</span> t</span> :::</span> Type </span>-></span> eq</span> t</span> -></span> t</span> -></span> t</span> -></span> bool</span></span></code></pre>
The signature of the eq</code> function looks familiar enough. We still don't know
what class eq</code> means, but by the way it's used in the function we can infer
that it's a constructor that takes one argument.</p>
In fact, eq</code> is just an abstract type</a>, i.e. a type whose
implementation isn't specified in its signature so that only the underlying
module can access it. If you don't know what that is, you can think of it as an
opaque pointer in C.</p>
In this case we can't look at its actual implementation because Basis</code> is
implemented directly in C, but it would look somewhat like this:</p>
con eq t = t -> t -> bool</span></span></code></pre>
So now we should have all the pieces to understand the eq</code> function above.
Or do we?</p>
If you were to define your own eq</code> constructor and your own eq</code> function,
you'd always have to pass a function of type eq t</code> as first argument.
(This kind of function can also be called witness</strong>.)</p>
con eq' t = t -> t -> bool</span></span>
</span>
fun eq' [t] (cmp : eq' t) (a : t) (b : t) =</span></span>
  cmp a b</span></span>
</span>
fun eq'_bool (a : bool) (b : bool) =</span></span>
  case (a, b) of</span></span>
  | (True, True) => True</span></span>
  | (False, False) => True</span></span>
  | _ => False</span></span>
</span>
val</span> test</span> =</span> eq' eq'_bool</span> True False</span></span></code></pre>
But if we were to do the same with eq, we would get a compiler error.</p>
Turns out that the eq</code> function is just the desugared name of the =</code>
operator, and as we've seen above, we can use it transparently without having
to worry about the witness function.
This is where the class</code> keyword comes into play.</p>
When we mark eq</code> with the class</code> keyword in a signature file, the compiler
will automatically search for a fitting implementation of eq t</code> every time we
call =</code> with a given t</code>.</p>
The option</code> constructor also defines an eq</code> witness in  the Option</code> module.
This is its signature:</p>
val</span> eq</span> :</span> a</span> :::</span> Type </span>-></span> eq</span> a</span> -></span> eq</span> (</span>option</span> a</span>)</span></span></code></pre>
This should be straightforward by now. Option.eq</code> implicitly takes a witness
eq a</code> and maps it to the value stored inside the option, if any. Let's take
a look at its implementation.</p>
fun eq [a] (_ : eq a) =</span></span>
    mkEq (fn x y =></span></span>
             case (x, y) of</span></span>
                 (None, None) => True</span></span>
               | (Some x, Some y) => x = y</span></span>
               | _ => False)</span></span></code></pre>
The wildcard corresponds to the witness argument, even though the function
doesn't use it directly. In a way, the witness argument is just there to
constrain</strong> the types we can call Option.eq</code> with to those for which there
exists an implementation of eq</code>.</p>
Now the error message should make sense: the compiler is telling us that this
invocation of =</code> has a constraint of type eq {A : int}</code> on its arguments,
so we need to implement a witness of eq</code> for {A : int}</code>. We'll have to use
the mkEq</code> function to do this.</p>
val</span> eq_a_int</span> =</span> mkEq</span></span>
  (</span>fn</span> (</span>a</span> :</span> {</span>A </span>:</span> int</span>}</span>) (</span>b</span> :</span> {</span>B </span>:</span> int</span>}</span>)</span> =></span></span>
    a</span>.</span>A = </span>b</span>.</span>A)</span></span>
</span>
(*</span> this will compile now </span>*)</span></span>
val ok</span> =</span> {</span> A </span>=</span> 1</span> }</span> =</span> {</span> A </span>=</span> 1</span> }</span></span></code></pre>To be continued...</h2>
This post is getting pretty long, so I'll wrap it up here for this week.
If you already knew most of the things I covered here, don't worry, the next
one is gonna cover some of the most foreign parts of the type system.</p>
Watch this space for part 2! (I promise I'll implement an RSS feed soon.)
In the meantime, you might want to brush up on monads</a>,
or take a look at the more dense official tutorial</a>.</p>


Overthinking cash in TypeScript
steen — Sun, 11 Nov 2018 00:00:00 +0000
</p>
Part of my current project at work deals with monetary values in the form of
cash, making change, and displaying the bills and coins on the screen.</p>
Since I recently started adding types to certain parts of the codebase with
TypeScript, I thought it'd be fun to see how elaborately I could model the
types of the values and of the functions using TypeScript's more advanced
features, and while I was at it, how easy it would be to parametrize the types
based on the currency you're dealing with.</p>
First of all, I'm gonna define what I mean by "cash". Since I need to show
the bills and coins on the screen at scale, I need to know their color and
their dimensions, and here's the issue: coins only need a width, but banknotes
also need a height, so I can't use the same type for both.</p>
interface</span> Coin</span><</span>Amount</span>> {</span></span>
  amount</span>:</span> Amount</span>;</span></span>
  color</span>:</span> string</span>;</span></span>
  width</span>:</span> number</span>;</span></span>
}</span></span>
</span>
interface</span> Banknote</span><</span>Amount</span>> {</span></span>
  amount</span>:</span> Amount</span>;</span></span>
  color</span>:</span> string</span>;</span></span>
  width</span>:</span> number</span>;</span></span>
  height</span>:</span> number</span>;</span></span>
}</span></span></code></pre>
Now I have to store these values somewhere. Using two objects, one for the
coins and one for the banknotes, would be the simplest solution, but it would
complicate things at the call site when we don't know whether the amount is
a coin or a banknote.</p>
const</span> cashInfo</span> =</span> (</span>amount</span>:</span> CashAmount</span>)</span>: ??? =></span> (</span></span>
  amount</span> ></span> 200</span></span>
  ?</span> banknotesByAmount</span></span>
  :</span> coinsByAmount</span></span>
)[amount]</span>;</span></span></code></pre>
This is not a very elegant piece of code, and TypeScript doesn't like it much
either.</p>
</p>
Dependent (kinda) types to the rescue!</h2>
TypeScript 2.8 introduced conditional types</a> which (as I understand it)
are a light form of dependent types, like the ones in Coq or Idris. You can use
them to implement basic arithmetic with peano numbers, which is cool as hell,
but unfortunately not very useful in real code (at least at the moment).</p>
Now I can define a type which returns either Coin</code> or Banknote</code> depending
on the type of its argument:</p>
type</span> ByAmount</span><</span>CoinAmt</span>,</span> BanknoteAmt</span>,</span></span>
  Amt</span> extends</span> CoinAmt</span> |</span> BanknoteAmt</span></span>
></span> =</span> Amt</span> extends</span> CoinAmt</span>     ?</span> Coin</span><</span>Amt</span>></span></span>
  :</span> Amt</span> extends</span> BanknoteAmt</span> ?</span> Banknote</span><</span>Amt</span>></span></span>
  :</span> never</span>;</span></span></code></pre>
Note that I'm still parametrizing over the denomination to make it possible
to use different currencies easily, so the signature still looks a bit awful,
but it'll only need one type parameter when "instantiated".</p>
Defining the type of the object is now a breeze, thanks to mapped types.</p>
type</span> CashMap</span><</span></span>
  CoinAmt</span> extends</span> number</span>,</span></span>
  BanknoteAmt</span> extends</span> number</span>,</span></span>
  Amount</span> extends</span> CoinAmt</span> |</span> BanknoteAmt</span></span>
></span> =</span> {</span></span>
  readonly</span> [</span>A</span> in</span> Amount</span>]</span>:</span></span>
    Readonly</span><</span>ByAmount</span><</span>CoinAmt</span>,</span> BanknoteAmt</span>,</span> A</span>>></span>;</span></span>
}</span></span></code></pre>
Now we're ready to instantiate these types with a currency.</p>
Plugging in the Eurodollars</h2>
TypeScript doesn't have polymorphic variants</a>, but it does have
numeric literal types</strong>, which are just as good for our purposes.
Let's define the denominations.</p>
type</span> EuroCoinAmt</span> =</span></span>
  1</span> |</span> 2</span> |</span> 5</span> |</span> 10</span> |</span> 20</span> |</span> 50</span> |</span> 100</span> |</span> 200</span>;</span></span>
type</span> EuroBanknoteAmt</span> =</span></span>
  500</span> |</span> 1000</span> |</span> 2000</span> |</span> 5000</span> |</span> 10000</span> |</span> 20000</span> |</span> 50000</span>;</span></span>
type</span> EuroAmount</span> =</span></span>
  EuroCoinAmt</span> |</span> EuroBanknoteAmt</span>;</span></span></code></pre>
Now I can fill in the maps.</p>
type</span> EuroMap</span> =</span> CashMap</span><</span></span>
  EuroCoinAmt</span>,</span> EuroBanknoteAmt</span>,</span> EuroAmount</span></span>
></span>;</span></span>
</span>
const</span> euroByAmount</span>:</span> EuroMap</span> =</span> {</span></span>
  1</span>: {</span></span>
    amount</span>:</span> 1</span>,</span></span>
    color</span>: '</span>#b87333</span>',</span></span>
    width</span>:</span> 16</span>,</span></span>
  },</span></span>
  2</span>: {</span></span>
    amount</span>:</span> 2</span>,</span></span>
    color</span>: '</span>#b87333</span>',</span></span>
    width</span>:</span> 18.5</span>,</span></span>
  },</span></span>
  /* ... */</span></span>
  500</span>: {</span></span>
    amount</span>:</span> 500</span>,</span></span>
    color</span>: '</span>grey</span>',</span></span>
    width</span>:</span> 120</span>,</span></span>
    height</span>:</span> 62</span>,</span></span>
  },</span></span>
  /* ... */</span></span>
}</span>;</span></span></code></pre>
Since this is all static data, the compiler is able to verify that:</p>

I didn't forget nor invent any coin or banknote</li>
objects indexed by a BanknoteAmount</code> effectively have a height</code> field,
and that those indexed by a CoinAmount</code> don't</li>
the indexing key matches the amount</code> field</li>
</ul>
When I try indexing the object, the compiler will infer the correct type
based on the type of its argument, and complain when trying to index a value
that does not exist (though the error message for that is a bit confusing).</p>
euroByAmount[</span>500</span>]</span>;</span> // Readonly<Banknote<500>></span></span>
euroByAmount[</span>2</span>]</span>;</span>   // Readonly<Coin<2>></span></span>
</span>
// error: Element implicitly has an 'any' type</span></span>
// because type 'CashMap<EuroCoinAmt, EuroBanknoteAmt, EuroAmount>'</span></span>
// has no index signature.</span></span>
euroByAmount[</span>3</span>]</span>;</span></span></code></pre>
The advantage of keeping the more general types around is that we can now
differentiate between functions that work the same regardless of the currency,
and functions that might require a different implementation for each currency.</p>
In my project I have a function that returns a few reasonable change suggestions
given an amount of money, in which the optimal solution is calculated using a
simple greedy algorithm. This works for euros, where the greedy algorithm does
indeed return an optimal solution, but it might not be a good fit for other
currencies with different denominations, so in this particular case it makes
sense to use the specific types for euros, rather than the more general ones.</p>
Conclusions</h2>
TypeScript has a rather quirky type system with many features that vaguely
resemble those found in other languages but not quite, like literal types, and
some weird features taken straight from niche almost-research languages, like
conditional and mapped types, but somehow they all fit together rather nicely
to model the sort of JS code you'd write normally.</p>
This is TypeScript's biggest strength, in my opinion: I barely had to change
my code when adding types to this module, and it would still make sense if you
took the types out, even if I had written this in TS to begin with.</p>
Further reading</h2>

How to Handle Monetary Values in JavaScript</a></li>
Money in the type system where it belongs</a></li>
Dinero.js</a> - An immutable library to create, calculate and format money.</li>
</ul>


I survived Ur/Web
steen — Mon, 22 Jan 2018 00:00:00 +0000
I don't remember when it was that I first tried Ur/Web</a>, but I'm sure I
didn't last long with it. As soon as I strayed a bit from the examples provided
on the website (seemingly the only documentation available), I would hit a brick
wall, in the form of unreadable compiler errors. I got so frustrated that I
deleted all the files I was working on and the compiler with them, and I didn't
touch the language for a while.</p>
I'd try again after a few months, once again lured in by the
ludicrous promises listed on the front page of the website: no more complex
ORMs, no more crappy templating languages, no more brittle internal APIs, and
all of this packaged up in a neat ML-like language with a solid and powerful
type system that compiles down to very efficient C code. It was too good to be
true, and I wanted into it. Soon enough I'd hit another brick wall and the
cycle would repeat itself once again, until I got to the point where I was
confident enough in the language that I could write it for a few hours without
getting stuck too much.</p>
As it turns out, my frustration with it is one of the language's many features.
In the age of languages like Elm and Go, which jeopardize sophistication to
appeal to the newcomers, Ur/Web takes Haskell's motto of avoiding success at
all costs and runs with it. In the words of the language's creator</a>:</p>

I also want to emphasize that I'm not trying to maximize adoption of
Ur/Web.  Rather, I'm trying to maximize the effectiveness of people who
do choose to use it.  This means that I'm completely happy if basic
features of Ur/Web mean that 90% of programmers will never be able to
use it.</p>
</blockquote>
Seen from this perspective, everything starts falling into place. The homepage
straight from the late 90s, the few examples and the TeX-formatted PDF manual,
the lack of any sort of documentation to the standard library that doesn't
involve digging through the scantly commented signature files. It's all
intended.</strong></p>
Jokes aside, while I do find the approach to language design admirable, I think
the ecosystem could use a lot of improvement; at the very least some more
comments in the stdlib signature files and possibly some way to generate an
HTML page out of them, in the style of ocamldoc</code>. I've spent enough time
trying to differentiate queryL</code> and queryL1</code> that I've developed a feel for
it, but I'd much rather have a thorough explaination of why they're named like
that.</p>
The compiler also outputs errors which range from completely unhelpful parsing
errors to dozens and dozens of desugared XML and SQL statements which rival C++
template error messages in succintness and readability. As with the standard
library functions, the error messages are there to give you a feel for what the
compiler wants to see rather than to provide a useful explaination of what
happened.</p>
The good parts</h2>
I've only bashed the language up to now, so it's about time that I start
mentioning its good parts. Ur/Web is amazing! Part of the reason why I'm
writing this is in the hopes of getting even one other person interested in the
project, because I think it deserves more users.</p>
It's a long and winding road to get there, but Ur/Web does</em> deliver on its
promises of speeding up application development. Once you start working with
the compiler rather than against it, you'll find that you only have to worry
about the parts of your application that matter rather than getting entangled
in busywork. The compiler will not only check for mismatches in the types of
every function and value in the program like in a normal statically typed
language, but it will also check them against the database tables, cookies,
form fields and any other kind of client-server interaction; your program
simply won't compile if you query a column that doesn't exist.</p>
Defining tables, queries, cookies and RPC becomes pretty much effortless, and
you can achieve a much higher level of "separation of concerns" through
thoughtful use of the signature files. At first I tried going for a MVC-like
approach by putting all my tables and queries in a module and all pages in
another, but after a while I found that it makes more sense to define tables
and cookies right in the modules that need them, so as not to needlessly expose
them to modules that don't. Database tables and cookies in Ur/Web are somewhat
like normal types, so you can keep them as an implementation detail of a module
or expose them as needed.</p>
Ur/Web also compiles the client-side portions of your code to Javascript, so
you can write client code directly in the page handler</em> and run the same
functions both on the server and the client (as long as they don't use any
server- or client-specific features). Reactive page generation à la React</em> is
also supported through the <dyn/></code> tag, which lets you subscribe to a source</code>
(basically a mutable cell, similar to ref</code> in OCaml) and automatically reacts
when the source changes.  You can also push data asynchronously to a client with
channel</code> and call functions that need server features without reloading the
page with rpc</code> (which unfortunately doesn't support file inputs, but I'm
working on an AJAX library that will let you do that).</p>
The language works with a transactional model which marks every function that
will have a different output even with the same inputs (e.g. a random number
generator or a database query) with the type transaction</code>, and undoes any
changes that might have been made in case of an error. I had a bit of trouble
understanding the model, mostly because transaction</code> is a monad and I wasn't
acquainted with the concept when I first tried the language, but after a while
it became useful and natural to wall off the effectful functions from the rest
of the code.</p>
The future?</h2>
Ur/Web is far from perfect; even with a better ecosystem, documentation and
compiler messages, there's lots of things that annoy me (the "end" keyword
in let .. in .. end</code> blocks, the lack of a buffer type to make string
manipulation less painful for the allocator, the lack of support for
interacting with data types more complex than strings and integers in C
bindings, ...), but it still feels like working with a language from the
future. A future where frameworks are actually compilers aware of the
application domain, and will check non-trivial properties of a program for
correctness.</p>
That future, I think, is (or was) the end goal of the language's author, Adam
Chlipala. He seems to have envisioned Ur as a language that allows syntactic
and compiler extensions to fit any sort of application domain in a similar
manner. He looks more interested in other projects these days (though he's
still actively developing Ur/Web) so I doubt this will ever come to fruition,
but it might be a goal worth pursuing.</p>
Eduardo Julian, the author of the
Lux programming language</a>, gave a
talk at StrangeLoop</a> last year
where he talked with the fervor of a madman about a similar dream of letting
users of his language implement domain-specific optimizations, core features
and compilation targets without having to change the language itself.
Racket</a>'s goal is to be both a general-purpose
language and a language platform, with which users can implement their own
domain-specific syntax and let it interact with normal Racket code or other
domain-specific languages. There's probably other projects with similar goals
that I don't know of, so perhaps we'll see more of this in the future.</p>
Getting back to Ur/Web, if you like functional languages, hate the current
state of web development, can bear with the lack of documentation and
StackOverflow support, and already know a bit of Haskell/OCaml/SML, I
recommend you try it. It takes a while for it to click, but when it does it's a
wonderful experience, and you'll certainly learn something about types, MLs or
even web development in the process.</p>
For my part, I'll try to contribute some documentation to the project to make
it a bit easier to get into the language.</p>
Further reading</h2>

Polymorphic variants in Ur/Web</a></li>
</ul>


What the hell did I do this week, anyway?
steen — Mon, 22 Jan 2018 00:00:00 +0000
Welcome to the first installation of What The Hell Did I Do This Week Anyway</strong>,
the low-effort blog series where I write about random stuff that I did in the
last few days.</p>
Emacs strikes again, or the stages of software grief</h2>
This week I watched a bunch of Jonathan Blow's screencasts</a>,
where he talks about the language he's writing and all that business. It looks
nice. Lately he's working on libraries, and I wish he'd take a hint from ML
functors when designing modules and module options, as he's talked about in
the libraries discussion stream. Expose a fucking module for configuration and
make it return the full thing, using strings for that just feels painful.</p>
Anyway, he uses emacs for all the programming in his stream, save for debugging
a bunch of stuff in C++, and looking at emacs for all this time has reawakened
the little bug in my brain that tells me to start using emacs already. I use
nvim for everything, but I'm kind of horrified by the whole vimscript business
and at the very least elisp is a saner language.

Screw learning all those keybinds though. I've spent years on vim and I think
the modal editing business is a much better fit to editing code than the big
mess of emacs keybinds.
Screw using evil too, though, because emacs is not vi and I don't think it
should be. Screw all the minor modes that kind of mimic vi but also kind of
don't, and screw a lot of the packages that emacs comes preloaded with.</p>
I downloaded the emacs source and managed to compile temacs, which is the
"bare" version of emacs that gets filled in with all the preloaded libraries
and elisp code, and then gets "dumped" to the final emacs executable we all
know and fear. I recommend this</a>
for the gory details on this horrifying process.
I think there might be a few steps in the build process that should happen
after building temacs but before actually loading temacs and dumping it to
emacs, because I can't get the damn thing to work. I invoke temacs and tell it
to load loadup.el</code> (the file that loads all the plugins and tells emacs to
dump itself) but it keeps failing with some error message or another.
First it's pcase, then it's require, and who knows what the next will be.
Despite its reputation for being so hackable, this part of the build process
sure is not, and if it is it's very</em> undocumented.</p>
I started writing my own loadup file in hopes of getting it right, but I ran
into some files that supposedly provide Common Lisp support which for some
reason require</code> each other. At this point I gave up, because I was already way
past the treshold of time and effort I wanted to allocate to emacs that evening.
Thanks, jwz.</p>
The next step in the stages of software grief is starting to implement your own
version, because you're so</strong> done with whatever you were using before and its
alternatives and how hard could it possibly be anyway. Which is exactly what I
did, as soon as I remembered that Racket came with a perfectly good library for
drawing stuff on the screen, on top of which they implemented a GUI library and
the very nice editor/IDE DrRacket.
I looked up how Racket implements the editor window, and the results weren't
exactly what I'd call readable or encouragings, after messing a bit with the
canvas%</code> class I decided to give up for the moment.</p>
Which is where I reached the last stage of software grief, in which I changed
my vim colorscheme to deus</a> and called
it a day.</p>
Eight whole bytes of security</h2>
I was working on my Ur/Web imageboard, when I noticed that I accidentally typed
"passwords" instead of "password" and still managed to log in. I looked up the
implementation of crypt</code> (the only password hashing function provided in
Ur/Web) in the runtime library and discovered that it uses OpenSSL's
DES_crypt</code>, which clips passwords to 8 characters (!) and has been deemed
obsolete for decades now (with good reason). I don't know what the
production-class Ur/Web applications do for password hashing, but thankfully
searching for crypt</code> in both the Bazqux Reader and UPO repos doesn't turn
up any results. Either way, nobody had bothered to write Ur/Web bindings to a
better password hashing algorithm, so I figured I'd do it.</p>
The result is this library</a>, which
uses Solar Designer's implementation of the algorithm. It only exposes two
functions, so integrating it with my imageboard only took something like two
minutes. I'm quite satisfied with it, though it could probably use some tests.</p>
The other result is that I've submitted a PR with a comment on the crypt</code>
function in the Ur/Web standard library, essentially explaining that it's
insecure and you should probably consider an alternative (such as my library).</p>


The social issues of programming languages
steen — Sun, 29 Oct 2017 00:00:00 +0000
I'm sure you know what bikeshedding means, and even if you don't, you've probably
experienced a high amount of it in some way or another. It's a folkloristic1</a></sup>
programming term that describes the endless discussion over trivial aspects of a
piece of software, such as spaces vs tabs, or which of the zillions of JS build
systems to use, or whether operator overloading should be allowed. We'll call these
social issues</em>.</p>
The great thing about social issues is that they only exist when more than one person
is working on a project. If it's just you, you don't have to worry about coding
style guidelines. You don't have to worry about what paradigm you want to use, or
to get everybody comfortable with the set of macros you're using, or with the libraries,
or the build system. In fact, you won't have to worry about reproducing the build
environment on machines other than your own. You might even get away with not documenting
your code, even though your future self will hate you for that.</p>
Rudolf Winestock in his famous article
The Lisp Curse</a> argues that
"Lisp is so powerful that problems which are technical issues in other programming
languages are social issues in Lisp."</em> This makes Lisp a great language for lone
hackers, because those social issues are easily solved by oneself, but terrible
for working with other people, because you'll have to spend so much time just defining
a common language that everybody agrees to use that you'll never see the end of it.</p>
This is a problem in C++, too: the joke goes that the language is so big and full
of features that you'll end up using only 10% of it for any given task, but everybody
disagrees on what that 10% should be.</p>
Enter Go</h2>
Go is a pretty unremarkable</a> programming
language, with a feature set that rivals</a> that
of languages from the 60s, and it's also one of the most popular programming languages
of the last few years. I think the reason is that whatever thought didn't go into
making a good programming language went into solving the social issues that the
other languages suffer from, and if you ask people who have experience with many
languages what they like about Go they'll mostly praise what you could call its
"user experience".</p>
Go tries to solve the social issues by providing solutions for them by default in
its standard installation, down to including a code formatter that the vast majority
of projects require you to run before committing any code to source control.</p>
Go also makes lots of tradeoffs in the language itself to make compilation faster:
the type system is very limited and you don't get type inference other than some
syntactic sugar for C++'s auto</code> keyword, because the compiler would have to perform
more extensive type checking. Generics also don't exist, because you'd have to generate
code for each instantiation at compile time.</p>
I personally don't agree that these tradeoffs are really worth it, but it seems
to be working. People love Go (i.e. its tooling), and they love how they don't have
to think about all the things Go provides anymore, which I think raises a good point:
isn't not worrying about the unimportant parts what programming languages are about?
And if so, what good is a new language that doesn't try to solve these issues?</strong></p>
Lessons to be learned</h2>
I think that there's lots of better languages out there that should learn a thing
or two from Go, if they want to succeed.</p>
Elm seems to be a step in the right direction: it takes a lot from Haskell, and
makes a lot of decisions and tradeoffs to be easier to learn for newcomers. Elm
places a tremendous amount of effort into appealing to newcomers by having a very
small core language, integrating many tools into its standard distribution like
Go, and making error messages look very friendly and easy to understand.</p>
Then again, many of these improvements are implemented without regard for the more
experienced developers. Elm is a great language and its architecture is a really
good paradigm, but many complain that it scales poorly when project sizes increase,
and without stronger abstraction facilities like type classes you're bound to end
up with a lot of boilerplate. Frankly, I don't think Evan himself knows where he
wants to bring the language in the future.</p>
Reason</a> also seems to be somewhat promising, being
funded by Facebook and all. It's nothing but a layer of paint on top of OCaml to
make it look more like Javascript, but somehow it's managed to make people buy into
it. The Reason team also seems to be working on the OCaml compiler to make it produce
error messages that look like Elm's. With a bit of luck, this will bring more people
over to OCaml and, over time, improve its ecosystem.</p>
^1</sup>I've stolen this use of the term from this talk</a> by Bryan Cantrill. It's a good talk.</p>
</div>


Continuations, Promises, and call/cc
steen — Fri, 27 Oct 2017 00:00:00 +0000
Say you're in the kitchen in front of the refrigerator, thinking about continuations.
You make yourself a sandwich right there and stick it on your desk.
Then you sit on your armchair and open a browser window to search for their definition.
You get a series of abstract explainations, and some examples involving fridges and
sandwiches, which leave you more puzzled than when you began.
You invoke the sandwich on your desk, and you find yourself wondering if the topic
is even worth going through all this trouble to learn about.</p>
Promises</h2>
Javascript has a concurrency model which can be somewhat daunting at first:
it relies on asynchronous functions, which have to be handled differently from normal ones.
If you've ever written any JS in the last few years you must've used a lot of Promise</code>s,
async</code>s, and await</code>s, but if you haven't here's a quick reminder.</p>
Promise</span>.</span>resolve</span>(</span>2</span>)</span></span>
  .</span>then</span>(x</span> =></span> x</span> +</span> 1</span>)</span></span></code></pre>
The value of Promise.resolve(2)</code> is not quite 2, but rather a computation</em> that yields 2.
The only way to increase that 2 is by passing a function to its Promise.</p>
Javascript does this because it runs on a single thread, and making long blocking
computations (like an AJAX request) run synchronously would make the rest of the program,
and the whole page it's running on, lock up while it's waiting for that computation to finish,
and you really don't want that to happen on your website.
But try as you might, you will never be able to make that Promise return a 2,
store it in a variable and resume with your normal program flow,
like you'd do with a normal function (even though the async</code>/await</code> constructs adds a bit of
syntactic sugar to make handling Promises similar to normal code).</p>
The only way to access Promised values you're left with is passing a function to their Promise
with the rest of the computations that have to performed on that value.
This style of programming is called continuation-passing style</strong> (CPS).</p>
Continuations</h2>
Simply put, the continuation to a certain value is the part of the program
that needs to wait for that value to continue execution ("the rest" of the program).</p>
Continuations are easily represented by functions (but not quite1</a></sup>) like the ones you
pass to a Promise.
Take a simple program stuff() + 2</code>. The continuation of stuff()</code> could be represented
by the function x => x + 2</code>, while the continuation of 2</code> would be x => stuff() + x</code>.</p>
Promises can never return a value, so the only way to do something with their result is to
reify</em> their continuation to a function. Reifying a continuation involves a simple rewrite
that wraps the continuation in a function taking one argument, and replaces the value
with that argument.
This rewrite is applied by many compilers as an intermediate step to simplify the language.</p>
For example, take the classic definition of the factorial function:</p>
function</span> fact</span>(</span>n</span>) {</span></span>
  if</span> (n</span> ==</span> 0</span>)</span> return</span> 1</span>;</span></span>
  else return</span> n</span> *</span> fact</span>(n</span> -</span> 1</span>)</span>;</span></span>
}</span></span>
</span>
fact</span>(</span>3</span>)</span>;</span> //=> 6</span></span></code></pre>
We could rewrite this in CPS by taking the continuation of
the tail invocation of fact</code> and reifying it to a function,
then passing that function to fact</code> and calling it on the result.</p>
function</span> factCont</span>(</span>n</span>,</span> cont</span>) {</span></span>
  if</span> (n</span> ==</span> 0</span>)</span> cont</span>(</span>1</span>)</span>;</span></span>
  else</span> factCont</span>(n</span> -</span> 1</span>,</span> x</span> =></span> cont</span>(n</span> *</span> x))</span>;</span></span>
}</span></span>
</span>
factCont</span>(</span>3</span>,</span> console</span>.</span>log)</span>;</span> //=> 6</span></span></code></pre>
If you pass two functions to it, one representing success and the other failure,
you have Promises! (without the asynchronicity.)</p>
For more a more thorough explaination and some advantages of this style, I recommend
Matt Might's</a>
posts</a>
on the topic.</p>
call/cc</h2>
The problem with CPS is that nobody in their right mind would willingly write their code
like this. Most languages offer a few constructs that have similar effects to some of
the uses of explicit continuations, such as early returns, exceptions, gotos, or async/await.
Others, like Scheme, SML and Ruby</a>,
give you first class access to raw undelimited continuations through a
construct called call-with-current-continuation</em>, abbreviated to call/cc</code>
or callcc</code>.</p>
call/cc takes a function of one argument, and calls it with the current (relative to
where call/cc was called) continuation as its argument (historically called k</code>).
Invoking k</code> with a value, also referred to as "throwing", will set the
continuation to that value, thus emulating an early return.</p>
(call/cc</span></span>
  (</span>lambda</span> (</span>return</span>)</span></span>
    (display 'before)</span></span>
    (</span>return</span>)</span></span>
    (display 'after)))</span></span>
; => before</span></span></code></pre>
Storing the current continuation in a mutable cell allows one to return to that point in
the program from anywhere else, in a way that's similar to gotos or C's setjmp</code>/longjmp</code>.</p>
(define counter #f)</span></span>
</span>
(</span>let</span> ((x </span>0</span>))</span></span>
  ((</span>lambda</span> ()</span></span>
     (call/cc (</span>lambda</span> (k) (set! counter k)))</span></span>
     (set! x (</span>+</span> 1</span> x))))</span></span>
  (display x))</span></span>
; => 1</span></span>
(counter) </span>; => 2</span></span>
(counter) </span>; => 3</span></span></code></pre>
Combining these two cases, one can implement even more complex and convoluted control
flow structures, like exceptions, coroutines, or logic programming-style backtracking.
The implementations are a pain to write so I left them out</s> left as an exercise to
the reader.</p>
There have been a number of points</a>
raised against call/cc and first-class access to undelimited continuations, many
of which propose delimited</em> continuations as a cleaner, less costly alternative,
but I'll be taking a look at those in a later post.</p>
Sandwiches</h2>
Getting back to the sandwich example (or sand-witch, as the author of this quote</a>
stubbornly calls it):</p>

Say you're in the kitchen in front of the refrigerator, thinking about a
sandwitch.  You take a continuation right there and stick it in your
pocket.  Then you get some turkey and bread out of the refrigerator and
make yourself a sandwitch, which is now sitting on the counter.  You
invoke the continuation in your pocket, and you find yourself standing
in front of the refrigerator again, thinking about a sandwitch.  But
fortunately, there's a sandwitch on the counter, and all the materials
used to make it are gone.  So you eat it. :-)</p>
</blockquote>
It becomes obvious once you translate it to code:</p>
(define (eat-sandwich sandwich)</span></span>
  (display </span>"</span>burp</span>"</span>))</span></span>
</span>
(</span>let</span> ((pocket #f)</span></span>
      (fridge '(turkey bread))</span></span>
      (counter '()))</span></span>
  ; in front of the refrigerator</span></span>
  (call/cc (</span>lambda</span> (k) (set! pocket k)))</span></span>
  (</span>if</span> (</span>and</span> (empty? counter) (</span>not</span> (empty? fridge)))</span></span>
    (</span>let</span> ((sandwich (</span>cons</span> (</span>car</span> fridge) (</span>cadr</span> fridge))))</span></span>
      (set! fridge '())</span></span>
      (set! counter (</span>list</span> sandwich))</span></span>
      (pocket))</span></span>
    (eat-sandwich (</span>car</span> counter))))</span></span>
; => burp</span></span></code></pre>
The program saves its continuation. Then it checks if there's anything on
the counter and, finding nothing, it makes the sandwich and invokes the
previously saved continuation, returning to the beginning of the conditional.
This time it finds a sandwich in the counter, so it can start eating.</p>
Lucky bastard. It gets to travel back in time, while I'm left here writing posts
that the past me will never get a glimpse of.</p>
^1</sup>It is important to remember that undelimited continuations are not proper functions, because they cannot in any case return a value: in a typed language aware of continuations, a continuation would have a return type equivalent to TypeScript's never</code></a>, or a type annotation like C's _Noreturn</code></a>. See Oleg Kiselyov's explaination</a> for more information on this.</p>
</div>


The TTY Protocol
steen — Fri, 10 Feb 2017 00:00:00 +0000
A few months ago, Gary Bernhardt</a> streamed himself
writing a text editor. I'm not sure he ever finished it, and for some reason he took down
the VoDs on Twitch, but the little I've seen was still very interesting.</p>
Writing my own text editor (and using it) has always been one of my dreams and, being a
vim user, I'd much rather have it run on my terminal. Bernhardt shares my opinion, so he
started by writing (or rather, copying from one of his previous projects) the terminal
interaction code. I've always thought terminal interaction would be pretty complicated,
but it turned out to be a very small amount of code.</p>
This got me wondering about the protocol.</p>
A brief, incomplete, and mostly wrong history of the TTY protocol</h2>
The TTY protocol predates computers by quite a bit, and hasn't changed much since the
late 19th century. The protocol was created for teletypewriters</strong>, or teletypes,
to communicate with each other: it included not only printable characters such as
numbers, alphabets, and punctuation, but also directives for the teletype that were
not supposed to be printed called control characters</strong>, such as Line Feed (\n</code>).</p>
The character encodings that we still have to deal with nowadays also largely
come from back then: Unicode later tried to patch them all together, but it was already too late.</p>
Then computers came along. Printing the result of a computation to a sheet of paper
was way easier than interpreting a bunch of lights on a front panel, so they stuck
teletypes to them, and thus computers learnt the TTY protocol too.</p>
When screens became widespread, the protocol acquired more commands known as
escape sequences</strong>, so called because they were prefixed by
ESC (0x1B</code>). These allowed computers to move the cursor arbitrarily on the screen,
clearing part of it or applying some effects such as inverting the background and
the foreground color.</p>
Some terminals, such as the Tektronix 4010 series, also allowed drawing lines on
the screen thanks to their vector displays. These unfortunately died an untimely
death (even though a tek emulation mode still lives on inside xterm), and only the
text-based VTs stuck.</p>
Summing up</h2>
For most intents and purposes, /dev/tty</code> still behaves a lot like a physical
typewriter: you can scroll the "sheet of paper", you can move the cursor
around, you can imbue its head with colored ink or special effects. You can easily
find your way around with a control sequences chart</a>,
and it's not hard to emulate ncurses or readline just by printing a few characters
in raw mode</a>.</p>
The TTY is unfortunately very stateful, but termbox</a>
provides a very nice abstraction: it essentially turns all interactions stateless by printing a few more escape sequences every time you write something.</p>
I'm not sure if I'll ever write my own text editor, but it's certainly fun to play
with terminal graphics and line editing using nothing but write</code>.</p>
Further reading</h2>

Gary Bernhardt - A Whole New World</a></li>
Four Column ASCII</a></li>
The TTY demystified</a></li>
Declarative terminal graphics for OCaml</a></li>
Playing with Tektronix emulation for vector graphics!</a></li>
notty: A new kind of terminal</a></li>
Daniel Morsing - UTF-8</a></li>
How Unix erases things when you type a backspace while entering text</a></li>
When monospace fonts aren't: The Unicode character width nightmare</a></li>
</ul>

steen's burrow

Enumerate your logs

Building smaller Docker images faster

Hacking on the reMarkable 2

My Immich setup feat. NixOS

About this blog

The masculine urge to reinvent the wheel

Simple Python devshells with Nix and direnv

What do we want?</h2> Since this is a work project, let's talk requirements!</p>

The flake</h2> The flake where I keep my dev environments looks kind of like this:</p>

The end</h2> Repeat this for every Python repository you might have at your company. That's it! You can start working on the actual tasks in your sprint now.</p>

Do I not like Ruby anymore?

Solving Advent of Code 2021 Day 13 with a linear equation

Types of parser combinators

NixOps is easier than I thought

Hellpoint breach map

require_so: DRYer StackOverflow copying

Announcing SatouinDp

The journey of packaging a .NET app on Nix

Finally running the bot</h2> Nothing much has changed in the main derivation. I just added the link farm derivation to the list of dependencies and set it as source in the dotnet publish</code> command.</p>

Thoughts on Suspense for data fetching

Config constraints in the type system where they belong

A brief history of JAVAScript

A data-fetching component in React

Reading Ur/Web signatures, part 1

Generics</h2> Let's kick things up a notch. Open up list.urs</code> and you'll be greeted by something like this:</p>

To be continued...</h2> This post is getting pretty long, so I'll wrap it up here for this week. If you already knew most of the things I covered here, don't worry, the next one is gonna cover some of the most foreign parts of the type system.</p>

Overthinking cash in TypeScript

I survived Ur/Web

What the hell did I do this week, anyway?

The social issues of programming languages

Continuations, Promises, and call/cc

The TTY Protocol

The end</h2>
Repeat this for every Python repository you might have at your company. That's it! You can start working on the actual tasks in your sprint now.</p>