Daniel Moerner

Goodbye OpenAI

Sat, 28 Feb 2026 08:11:51 -0500

I have canceled my personal subscriptions to ChatGPT and committed to not using Codex or ChatGPT at work going forward. I cannot continue to support a company that shows such disregard for my values and the values of its employees.

Last night, Sam Altman, the CEO of OpenAI, announced that OpenAI would be entering into an agreement with the Department of Defense to use their models:

Tonight, we reached an agreement with the Department of War [sic] to deploy our models in their classified network.

The Pragmatic Programmer in 2025

Tue, 15 Jul 2025 20:12:23 -0400

Over the past few weeks, I read through the 20th Anniversary Edition of The Pragmatic Programmer, by David Thomas and Andrew Hunt (2019). I’ve often seen this book praised as a practical resource for software development. In this low-effort blog post, I’m just going to reproduce a few of my notes on what I found interesting or puzzling here. The book is divided into 53 Topics, which I use to organize my notes.

On Interviewing in Tech and Academia

Sat, 24 May 2025 09:54:18 -0400

I’ve recently switched careers from academia to software engineering. Some reflections on the interview and job market in these two different fields.

Adversarial and Non-adversarial

In my experience, every step in the interview process in academia is adversarial. This both characterizes my own experience as an interviewee, and the interviews I gave as a faculty member of at the University of Chicago. The first step in each meeting is to get the interviewee to commit to something; the second step is to object to it. This patterns holds from group interviews, to job talks, to one-on-one meetings, and even to casual meals. Many one-on-one meetings begin with an upfront claim that it will not be a discussion of work; they almost inevitably evolve into a series of debates.

How to Make a One-Click File Upload Button in Svelte

Thu, 06 Mar 2025 17:50:17 -0500

I’ve recently started using Svelte for some personal projects, like SvelteClick and PyTorrent, which is a collaborative project developed with Lamone Armstrong. While writing the front-end for PyTorrent, I wanted to make a one-click file upload and submit button. Why? Because this is ugly:

And this is nice:

Sure, you can style the former, but the problem is that the workflow is clunky: There’s no reason to make the user click twice just to upload a file. This blog post outlines how I failed and then how I got it working. Thanks to Teon Brooks for pairing on this with me!

When do you need nonlocal or global in Python?

Wed, 19 Feb 2025 09:23:52 -0500

I recently realized I had a slightly hazy understanding of name scope in Python. I knew I needed to use global or nonlocal in some instances, but I wasn’t exactly clear when and where they were needed. In practice this means scattering them everywhere they might be used.

I think I figured it out, and it’s really quite simple, but I didn’t find as clear a statement as I would have liked in the documentation. This post draws on the official Python 3 documentation and PEP 3104 - Access to Names in Outer Scopes, as well as my own testing.

etracker Public Demo

Mon, 17 Feb 2025 18:25:06 -0500

Over the past two months I have been sharing work here and on Github on a new BitTorrent tracker etracker. I’m happy to share that a public demo is now available: https://etracker.moerner.com/. The public demo is deployed with a small infohash allowlist consisting of recent Linux ISOs. An expanded frontend with support for suggesting allowed infohashes is under development.

To briefly summarize: etracker is a tracker designed to contribute to solving free-riding problems in the BitTorrent protocol at the tracker level. Clients which behave poorly (failing to seed snatches; failing to upload more than they download) receive proportionately less peers from the tracker than clients which are well-behaved. New BitTorrent clients to the tracker receive a full complement of peers, so there is no startup penalty when initially joining the tracker.

fatal: bad object HEAD

Sat, 08 Feb 2025 13:19:48 -0500

Thanks to all my friends and colleagues for such a wonderful in-person week at the Recurse Center hub in Brooklyn. I got so much out of the pairing, the social environment, and especially the opportunity to present my work in-person at Presentations+. Part of me wishes I had spent a week in-person earlier, but part of me also believes it was so great precisely because it was so late in the batch and my work was in a good place for collaboration.

Learning React and Rethinking JavaScript's Warts

Wed, 29 Jan 2025 10:44:51 -0500

There are many ways to do the same thing in every popular programming language, but not all of them are made equal. (I presume this is a corollary of Turing completeness.) This is why it is so important when learning a new language to get a grip on common patterns and anti-patterns. Otherwise we risk making the wrong choices (like assuming that tail recursion is always the optimal recursive algorithm even though with small inputs the time costs of reversing the result may be larger than the benefits in space complexity), or being paralyzed by the thought of too many choices (like I felt when I learned the Node fs module provides three interfaces that all do the same thing).

Bad Counterpoint, and MIDI and HTML5 in 2025

Tue, 21 Jan 2025 20:48:04 -0500

Today I spent some toy throwing together a toy music generator in Python, Bad Bach. Counterpoint is a musical style with roots in the Renaissance which follows a strict set out of rules. I set out to deliberately write bad counterpoint, or what I later learned is called dissonant counterpoint, which breaks as many of those rules as possible. I initially approached this as a puzzle solver problem, with the goal of maximizing under a set of constraints. However, I realized this music would be too deterministic for my taste. So instead I constructed a set of weights for (breaking) each rule, and then randomly generate rule-breaking harmonies based on those weights.

Is Communication within the Youtube Apparatus Meaningless?

Tue, 14 Jan 2025 18:57:51 -0500

Over the past day there has been discussion of a provocative essay by Kevin Munger, in the belly of the MrBeast, which builds on his recent book The YouTube Apparatus. I want to applaud the author for publishing this under CC-BY-NC 4.0, since otherwise I wouldn’t be able to read it.

Central to both essay and book is the thesis that there is something meaningless about YouTube. As the book puts it, “This is what I mean by nihilism: Communication within the YouTube Apparatus has no meaning.” As summarized in the essay:

A Curious Moon in Podman or Docker

Sun, 12 Jan 2025 10:34:11 -0500

I recently started working through A Curious Moon, a wonderfully clever data science “mystery” in PostgreSQL. The setup in the book uses Postgres on bare metal, but I wanted to use Postgres in Podman, which is like Docker. One interesting suggestion in the book is to use a Makefile to organize ETL. But this needed a little massaging work with Podman on Fedora, which I want to share here.

Here is my Compose file:

Brainstorming BitTorrent Peer Distribution Algorithms

Thu, 12 Dec 2024 12:55:53 -0500

Recently, I’ve been working on etracker, an experimental BitTorrent tracker designed to incentivize healthy client behavior. If you already know about the Bittorrent protocol or about my project, feel free to skip ahead to the actual brainstorming.

Project Background

BitTorrent is a P2P file transfer protocol, which can use centralized trackers to distribute peer lists to clients, who in turn connect to each other. A collection of clients announcing a particular content infohash is a swarm, which consists of some clients “seeding” content they already have, and other “leeching” content they do not yet have. A tracker must keep track of many clients, each in one or more swarms.

Where can you use a PostgreSQL parameter placeholder?

Wed, 11 Dec 2024 15:54:46 -0500

This blog post is mostly a note to future me. As I work on my latest Go project etracker, I’ve been using PostgreSQL for the first time, using the excellent pgx driver.

When writing dynamic statements, best practice is to use a parameter placeholder:

_, err = dbpool.Exec(context.Background(), 
    `INSERT INTO peers (peer_id, ip_port, info_hash) 
    VALUES ($1, $2, $3) 
    ON CONFLICT (peer_id, info_hash) 
    DO UPDATE SET ip_port = $2;`,
    announce.peer_id, announce.ip_port, announce.info_hash)

Although the pgx driver supports this with variable parameter methods, it’s just an abstraction on top of the underlying PostgreSQL PREPARE statement:

Isn't Go Reflection Slow?

Tue, 03 Dec 2024 01:02:49 +0000

Sharing a short note about something which surprised me today.

I’ve just started working on a self-healing Bittorrent tracker, which uses tracker-level tools (peer allocation algorithms and error messages) to handle unhealthy Bittorrent swarms. Ordinarily, such unhealthy swarms (low seeder to leecher ratio, broken clients, etc.) are either ignored or are handled outside the protocol using a separate frontend. I want to explore to what extent they can be handled by the tracker itself, within the constraints of the Bittorrent protocol. For more information, check out the README on my Github, although none of this is actually implemented yet: https://github.com/dmoerner/etracker.

"For Historical Reasons": Go String and Int Conversion

Mon, 25 Nov 2024 20:15:44 +0000

Damilola Israel Oluwole and I have started learning Go, and decided to play around with the language to write a toy implementation of Run-length encoding. While working on this little project we ran into a corner case with Go type conversion, which turns out to be documented in the Go spec but neither of us were aware of.

Run-length encoding is a simple lossless text compression algorithm which encodes each sequence of n identical characters c into the substring “cn”. For example, “Hello” is encoded as “H1e1l2o1”, and “AAAAAAAAAAH” is encoded as “A10H1”. Obviously in the worst case, a string with no adjacent identical characters, an RLE encoding of a string of length n requires length 2n. However, in the best case, a string which consists of a single sequence of a single character, the encoded length scales as the ~~square root~~ log of the original length. (Thank you to Charles Eckman for the correction!) Our implementation can be found on Github: https://github.com/dmoerner/go-rle.

When Impossible Day Feels Impossible: /tmp Inode Exhaustion

Tue, 19 Nov 2024 21:16:04 +0000

Impossible Stuff Day is a special sprint at the Recurse Center devoted to working beyond the edge of your abilities. I had an ambitious day planned around MirageOS microkernels, but I made one critical mistake: I did not test my OCaml development environment with MirageOS.

But that’s no problem: There’s a nice guide to install MirageOS, and it looks pretty simple. We can install MirageOS and confirm that the Hello World tutorial works. However, it very much does not:

Benchmarking a Binary Search Optimization, from 1991 to 2024

Fri, 08 Nov 2024 20:00:00 +0100

While reading Chris Okasaki’s Purely Functional Data Structures I became aware of an interesting optimization for binary search proposed by Arne Andersson in his 1991 paper, A Note on Searching in a Binary Search Tree. This blog post is an investigation of this optimization, including some updated benchmarks in Go and OCaml.

Binary Search Algorithms

As a reminder, a binary search tree can be thought of as a data structure consisting of empty leaves and non-empty nodes; each node contains a value and pointers to left and right subtrees. A binary search tree must satisfy the BST Invariant: For any node n, every node in the left subtree of n has a value less than n’s value, and every node in the right subtree of n has a value greater than n’s value. This naturally suggests the following algorithm for binary search, implemented in Go:

About

Mon, 01 Jan 0001 00:00:00 +0000

Formerly an Assistant Professor of Philosophy at the University of Chicago, now taking a break to explore my passions in tech and coding at The Recurse Center. Here is a copy of my CV. Contact me at [email protected]">[email protected].

I also try to host public deployments and demos of many of my personal projects. A non-exhaustive list:

etracker, a BitTorrent tracker: https://etracker.moerner.com/
badbach, a music generator: https://moerner.com/awful-twinkle.html
svelteclick, an idle clicker game: https://moerner.com/svelteclick/
A CIDR calculator: https://moerner.com/cidr-calc/